LSD Docs/LSD Docs.iso/FILEZ/lsdspr06.dms/lsdspr06.adf/sculpt4d_2.doc.pp/sculpt4d_2.doc

Text File | 1990-09-07 | 202KB | 4,470 lines

                           Sculpt-Animate 4D- Part 2

                                                                        6-9
The Selector tools

    Many of the tools, commands and gadgets only work
with selected vertices, edges or faces.  We have already seen
a number of ways to select and deselect vertices, but this
function is so important that additional ways to perform it
will always be welcome.  It would be nice, for instance, to
select small groups of vertices, in a slightly more wholesale
fashion than double-clicking allows.

    There are two tools designed specifically for selecting
and deselecting vertices in this way.  If you issue the
command TOOLS SELECTOR, the cursor changes into a
yellow square.  This is the Selector Tool.  It represents a
cube that you can move around in three dimensions.  If you
pass the cube over a vertex it will become selected.  If this
does not seem to happen, it is because you are at the wrong
'depth' in that window.  Remember that you can only locate
a point in two dimensions in any one window.  Look in one
of the other Tri-View windows to see where the cube is
really located.

    You will quickly learn how to drag the Selector Tool
around in the Tri-View.  Just as the Tri-View is a box-
shaped 3D window that may be moved around in a larger 3D
space, the Selector Tool is a smaller box that moves around
within the Tri-View.  Any vertex that passes through this
box becomes selected.

    You will notice that the Selector Tool is always the same
size in the Tri-View windows, just like the other tool
cursors.  By zooming in and out within the Contract and
Expand Tri-View gadgets, you make your objects larger and
smaller relative to the Selector tool, so it may be used to
select individual vertices or large parts of your objects.
When you have finished with the Selector Tool, click the
right mouse button to drop it.

    While selection of vertices is very important, there are
likely to be times when you want to deselect one or several
vertices among many that are selected.  A tool to perform
this complementary function can be selected with the

                                                                        6-10

command TOOLS DESELECTOR.  This time the little cube
is purple and it deselects everything that passes through it.

Duplicating Objects

    Sometimes you will need several copies of the same
object.  The command EDIT ADD DUPLICATE, will cause
every selected vertex, edge and face to be duplicated.  The
duplicate is produced at exactly the same location at the
original, so it won't be visible.  If you use the Grabber to
move the original version (since it is selected), then the copy
will be revealed.  The copy is created in an unselected state.
You can use this command like a brush in a paint program,
to scatter duplicate objects wherever you please.

    Of course, every additional copy of an object puts an
additional load upon memory and computation.  If you plan
to create several copies of an object, you will probably want
to make your prototype with as few vertices as possible.
Use smoothing, not vertices, to round out curved objects,
and remember that excessive detail will usually be lost to the
screen's resolution.

Building mirror images

    Some objects, like a glove, come in pairs.  As in the
case of a pair of gloves, paired objects are often mirror
images of each other.  If you had painstakingly built a model
of a left glove, you wouldn't want to build its mate by hand,
and you don't have to.  Sculpt Animate's REFLECT
command will build the mirror image of an object
automatically.

    To use this facility, you must select all the vertices of the
object to be reflected.  Choose one window and position the
cursor in it, to the left of all the selected vertices.  The
imaginary plane of reflection will be vertical in the current
window and it will pass through the cursor position.

                                                                        6-11

Execute the command EDIT DO REFLECT, and a mirror
image will appear to the left of the cursor.

    You may place the cursor, and hence the plane of
reflection, at any position in the window, but if a selected
vertex lies on the plane of reflection (or within a few pixels
of it), then that vertex will not be duplicated.  Rather, it will
be shared between the object and its reflection.  This provides
and easy way to construct closed objects that have a plane of
symmetry.

    For example, a human head is approximately
symmetrical.  If you were to build the left half of a head, you
would only need to construct one eye, one ear and half a
nose and half a mouth.  You would have to take care that all
the vertices that are supposed to lie on the center plane do so
exactly.  To check this, see that they like in a straight line in
one of the windows.  If you select this window and position
the cursor on this line, then the reflect operation will
construct a complete head, with the halves 'stitched'
together.

Multiple use of the extrude tool

    The extrude tool was described in the last chapter, but it
can be used in conjunction with other tools to build many
different shapes besides simple cookie cutter slabs.

    Suppose you wished to build a cylinder with a rounded
45 degree bend, perhaps a model for some plumbing fixture.
Before you do anything else, clear the Tri-View with EDIT
ERASE ALL.  The first construction step is to click on the
north window and construct a circle using EDIT ADD
CIRCLE.  Now move to the west window and expand the
Tri-View about three times, then select all the vertices.
Move the cursor to the bottom left corner of the west
window and execute the menu command TOOLS
EXTRUDE.  Move the cursor straight across the west
window, to the middle of its bottom edge.  This will drag
out an extrusion of the circle, making a cylinder.  Press the
right mouse button to disengage the Grabber.

                                                                        6-12

    Move the Tri-View to the north so that the selected
vertices lie near the left side of the west window, three clicks
on the move Tri-View gadget should be about right.  Now
position the cursor directly below the selected vertices at a
distance about equal to half the diameter of the cylinder.
This point will be the center of the curvature of the curved
portion of the bend.  Execute the TOOLS EXTRUDE
command and immediately click on the clockwise rotation
gadget in the west window.  Repeat this sequence of
extrusion and rotation eight more times and you will have
completed a uniform 45 degree radiused bend.  Now all that
remains is to extend the pipe at the end of the bend.  You
could use the extrude tool again and extend it in a freehand
manner.

    A more accurate way to extend the pipe would be to use
the edge of the Tri-View as a guide, but to do that we must
first rotate the whole object by 45 degrees.  Make sure the
Grabber is turned off and click on the clockwise rotation
gadget while holding down the right Amiga key.  Only some
of the pipe's vertices are selected, though, so its edges will
be tangled horribly.  Don't worry, though, we have made an
intentional mistake to illustrate something.  All is not lost,
you just have to rotate the unselected vertices and all will be
correct.  To do this, select the command EDIT SELECT
SWAP, then you can rotate the rest of the object clockwise
by 45 degrees in the same way, holding down the right
Amiga key.

    Now that all's well, use EDIT SELECT SWAP to switch
the selection back to the end of the pipe.  The selected end
should now be lying in the horizontal plane.  To complete
the object the pipe must be extruded downwards.  To do this
while using the edge of the Tri-View as a guide, place the
cursor on the right side of the west window near the top and
execute the command TOOLS EXTRUDE.  Drag the cursor
down the right hand edge of the window and then turn off
the grabber.  Finally, select all and use MODIFY FACES to
invoke smoothing, call up a lamp, position the observer and
target, and create a snapshot of your masterpiece!

                                                                        6-13

The unslice operation

    Using the tools that we have described, there is hardly
any regular shape that you cannot build with precision and
ease.  The world is full of irregular shapes, though.  Unless
you wish to construct them one vertex at a time, you need a
way to build them more easily.  One very useful method,
that's often used in the 'real' world, is to join together a
number of 'formers' that describe an object's outline at
various locations along its length, as though stacking sliced
bread.  Common examples are airplane fuselages, canoes,
and the human ribcage.

    In the Sculpt universe, it's fairly easy to build such
formers.  They can be constructed in 2D in a single window,
using the Curve Tool, etc.  Once you have the formers built,
however, they need to be joined together.  Sculpt Animate
provides the Unslice operation to let you assemble such
'slices' into a solid shape.

    For the command to work, each slice must be a single
closed loop and all the slices must lie in parallel planes.

    To achieve this, construct your first slice in a single
window, using the CURVE tool.  After each loop is drawn,
go to another window and move the cursor to the position of
the next slice.  Then go back to the first window to draw the
next loop.  It is important to get the correct spacing between
slices, as well as getting the correct shape for each loop.

    If you resize the Tri-View windows so that the view you
work in is large and the other two are very narrow, you can
easily concentrate on a single slice.  You may want to
expand the Tri-View every now and then, though, and look
down the length of your object to see that all the formers are
lined up correctly.

    As always, save your work periodically.  Once you have
completed a set of slices, save them in a special file before
invoking the Unslice command.  Keep this file for later.
You will usually find it easier to edit the slices, if necessary,
than to alter the complicated object.

                                                                        6-14

    Make sure all the vertices that make up the slices are
selected, and that no other vertices are selected.  Execute the
command EDIT DO UNSLICE.  After a period of
calculation, the loops will be joined together by edges,
creating a single surface.  If the end slices are triangles, then
the surface will be closed.

    There is no unique way to link the loops, so the unslice
command uses a heuristic approach to tackle the problem.
Do not be surprised if the solid that it generates differs from
the one you anticipated.  Adding additional slices, so that
one slice is not too different from the next, will serve to
define the shape with more precision.

    The REFLECT operation can often be paired with the
UNSLICE operation.  Sometimes the REFLECT will be
performed first, and at other times it is best to do the
UNSLICE first.  In either case the idea is to create either a
half set of loops (like half a loaf of bread) or a set of half
loops (a loaf cut down the middle).  Again, save these
curves before constructing the full object.  You will probably
wish to make changes after you have seen the complete
object, and the bare profiles are valuable for this.

Hiding objects in the Tri-View

    You may have already created some scenes in Sculpt
Animate that tax the speed of the Amiga's processor.  With
complex scenes, it can take several seconds to refresh the
Tri-View whenever you perform an operation.  This aside,
the Tri-View can simply become cluttered with a lot of detail
that you may not need at a given time.  There will likely be
times when you wish parts of the scene would just be told to
'go away' for a while.  Fortunately, you can do this very
thing.  The command EDIT DO HIDE SELECTED
VERTICES will cause all selected vertices to disappear from
view.

    Hidden vertices will not take part in any Tri-View
operation, and do not require any processor time when the
screen is refreshed.  Hidden vertices, do remain in memory,

                                                                        6-15

however, occupying RAM.  You may hide part of you
scene at one time, then later hide some more.  Any edges or
faces that are built upon a hidden vertex will also be hidden.

    When you save a scene, hidden objects will be saved if
the 'Which?' item in the 'Save what?' requester is set to
ALL.  If this item is set to SELECTED, or if you use SAVE
OBJECT, the hidden vertices will not be saved.  This is
because hidden vertices cannot be selected.

    When you want to get the hidden vertices back, use the
command EDIT DO REVEAL HIDDEN VERTICES.

Creating more complicated objects

    So far, you have created a number of different objects,
and seen how even more objects can be created.  Still, we
have been dealing with relatively simple shapes.  There is a
reason for this: the majority of complex objects in the real
world are actually collections of simple shapes.  This may
seem obvious, but it deserves special comment because it
makes life so much easier.  It's better to build a house, for
instance, by creating the parts individually and putting them
together, than it is to construct it all in one piece.  The key to
successfully modelling a complex object is breaking it down
into constituent parts that can be easily dealt with.

    You might wonder just how to 'put the parts together'.
This depends on what you will be using the completed object
for.  It would be rather difficult, and in most cases
unnecessary, to join individual parts of an object
'physically'--trying to make them into a single piece by
carefully constructing interconnecting faces and edges.  If
two objects are close enough together in the scene that you
can't see a separation in the rendered image, they are
'connected' well enough.

    If you prefer, it's usually all right to let the faces of one
part intersect with those of another, so long as it does no
harm for a part to protrude through on the other side.  Sculpt
Animate will sort out intersecting faces for you.

                                                                        6-16

    On the other hand, there are some good reasons to tie
certain objects together more securely.  For instance, you
may want to be able to select the whole object with a single
SELECT CONNECTED command.  To connect parts in this
way, just use the EDGE MAKER tool or gadget create a
single edge, tying the two objects together.  A single edge
between two otherwise unconnected objects cannot make a
face, so the new edge will not be visible except in WIRE
FRAME mode.

    In chapter 9, you will learn a way to combine objects
'logically', giving parts of objects names combined in a
hierarchy.

    As you design models, you should take care that you
choose an appropriate level of complexity.  In Sculpt
Animate, it is possible to model objects to a ridiculous level
of detail.  Given enough RAM, you could put every scupper
on the hull of an aircraft carrier, or place every scale on the
wings of a butterfly, but such detail would never be seen in
the finished product.  To include it wastes time in rendering
as well as construction, and may make the scene to large to
render in available RAM.

    As you look at an object you want to model, think of
each part in terms of how you could create it.  An airplane
will have wings, a tail section, a fuselage, etc.  Each part
may itself be composed of several parts as well--the tail will
have a rudder and stabilizer, the fuselage will have a cockpit
and engine compartment.  At each level of detail, decide
whether an item will make any difference in the finished
image.  You will eventually learn where to draw the line.

    As you construct the parts, think of each one in terms of
how it resembles EDIT ADD objects, or objects you have
built before.  Objects will often have several parts that are
identical; never create the same part twice if you don't have
to, that's what DUPLICATE and REFLECT are for.  By
thinking of a scene in terms of parts, you can dispense
with the 'easy' parts quickly, and concentrate on the parts
that aren't so easy.

                                                                        6-17

    Most of the time, you'll find that the 'hard' parts aren't
that hard after all.  The primary reason that a new shape
looks hard is that you haven't done anything like it before.
The best defense against this is to thoroughly familiarize
yourself with the tools and commands that we have
discussed, and the kind of shapes they can create.

    Remember that once you have achieved a basic shape,
there are still any number of ways to transform it into the
object you want, by adding and deleting vertices, resizing,
spinning, etc.  Every new object you create will open up a
whole new range of possibilities.

                                                                        6-18

                                CHAPTER 7

                                THE WORLD

    This chapter discusses the world in which Sculpt
Animate objects reside.  Facilities are described for lighting a
scene and providing a ground and sky.

Creating lamps

    The shadows, highlights, and subtle nuances of shading
that give Sculpt Animate images a sense of reality depend
upon the illumination of the scene.  In chapter 2, we
introduced the EDIT ADD LAMP command, which placed a
lamp at the current cursor position.  The lamp is depicted in
the Tri-View as a white star.

    There is virtually no limit to the number of lamps that can
be created, but since each additional lamp increases the
amount of computation required to generate an image, it is
wise to try to use as few as possible.  It's a happy
coincidence that scenes with fewer lamps tend to look better,
too.

    For dramatic results, you can employ colored lighting.
In order to create a colored lamp, you must first use the
EDIT MODIFY LAMPS command.  This command calls up
a requester similar to the one you used to modify the color of
faces.  Set the sliders to pick the color that you desire.  There
is no need to dim the light with the value slider.  Instead you
can enter a number into the lamp brightness box.

    The brightness value given to a lamp set its effect
relative to other lamps in the same scene.  If you like, you
can think of this number as the wattage of the lamp, although
the lamp's 'absolute' brightness is irrelevant.  As we have
seen, Sculpt Animate employs an automatic exposure
technique in creating images, and its range of sensitivity is
extremely large.  For instance, a single ten-'Watt' lamp in a
given scene should yield the same image as a single
thousand-'Watt' lamp.  If both lamps were in the same

                                                                        7-1

scene, however, the ten-Watt lamp wouldn't have much
effect.  In either case, you shouldn't have to worry about the
overall brightness of the image.

    If you have used the MODIFY LAMPS requester to
change the current lamp color or brightness, then any new
lamps that are created with the EDIT ADD LAMP command
will have the new properties.  If you indicate a lamp with the
cursor before calling up the requester, you can use the two
SET buttons to change either the color or brightness of the
indicated lamp.  If you wish to reset the properties of all the
lamps in the scene, click on the button in the box titled
WHICH LAMP, and the button will toggle between
INDICATED and ALL.

    You can use the two sets of FETCH and BLEND
buttons, as appropriate, to fetch or blend lamp colors and
brightness, much as you did with the colors of faces.

    In Sculpt Animate, as in the real world, the brightness of
a lamp falls off according to the inverse square law.  This
means that if you quadruple your distance from the light, the
intensity falls to one sixteenth of its original value.  Sculpt
Animate's automatic exposure tries to find the best exposure
for the most brightly lit object, so if you place a lamp close
to an object, more distant parts of the scene may be very
dimly lit.  Try to avoid placing lamps much closer to one
object than to others, unless you want to create some special
effect.  For an even, overall light, like sunlight, place your
lamp five or ten times farther from the target than the
observer's location.

    If you want to move a lamp, you may do so with the
Grabber tool described in chapter 4.  First, be sure that all
vertices in the scene are deselected, then indicate the desired
lamp and invoke the Grabber as usual.

    Try to resist the temptation to add lamps if a scene seems
too dark.  The automatic exposure feature will compensate
for additional lamps, so they will usually not make a scene
brighter.  Instead, make sure the scene is lit evenly, with no
objects too near a lamp.  If you still want the scene lighter,

                                                                        7-2

use the OBSERVER EXPOSURE MANUAL setting to
brighten it.

    To see the effect of various lighting arrangements, try
rendering a few SKETCH mode images of a test subject.  A
one-subdivision white sphere does nicely.  Start with a
single lamp at or near the observer's location, then render a
few images, moving the lamp around towards one side a
little each time, until the subject is entirely side-lit.  You will
see that the shading of the sphere becomes deeper and more
dramatic as the lighting becomes more oblique.  It is usually
good also to raise the main light up above the level of the
subject, raising its highlights.

    As the obliqueness of the main light source increases, so
does the need for a second light--otherwise the shading
becomes too deep.  The second lamp, called a 'fill' light,
will usually be placed to the other side of the observer,
perhaps a little closer to the line of sight.  The fill light needs
to be dimmer.  While it is all right to reduce its 'wattage'
with the brightness setting, it may be easier to simply place it
a little farther away from the subject so you can see at a
glance which light has more effect.

    When you are using PHOTO mode, you will often want
dramatic shadows to be cast on the ground (the 'ground' is
explained later in this chapter).  If the subject is on the
ground, this can often be achieved by placing a third light
source relatively high, and somewhat behind the subject.
This 'backlight' should usually be as bright as, or brighter
than, the main light.  If the subject is above the ground or the
main light is far enough to the side, then the shadows cast by
the main and fill lights may be enough.  In some cases the
'main' light may be discarded, and only a backlight and fill
used.

    These are not rules, by the way, just basic suggestions to
get you started.  The only rules when it comes to lighting
are use your imagination, try things out, and remember the
arrangements that please you.

                                                                        7-3

Illumination

    Sculpt Animate employs a technique called low albedo
approximation when it generates an image.  This means that
any part of an object that is hidden from all light sources will
be totally dark.  Such objects will not pick up reflected light
from nearby illuminated objects.  In order to soften the
shadows, Sculpt Animate allows you to specify a diffuse
ambient illumination that is independent of the lamps that
you create.

                +---------------------------------------+
                |                                       |
                |       BACKGROUND ILLUMINATION         |
                |                                       |
                |    +------------------------------+   |
                |  R |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  G |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  B |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  H ||>                            |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  S ||>                            |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  V |    |>                        |   |
                |    +------------------------------+   |
                |                                       |
                |               +-------+               |
                |               |       |               |
                |               |       |               |
                |               |       |               |
                |               |       |               |
                |  +--------+   |       |   +--------+  |
                |  | CANCEL |   |       |   |   OK   |  |
                |  +--------+   +-------+   +--------+  |
                |                                       |
                +---------------------------------------+

                        The Illumination Requester

    You can change the amount of the illumination with the
command WORLD ILLUMINATION.  This brings up an
illumination color requester that you operate in the same way
as other color requesters.  Unlike the lamps, there is no
separate brightness facility for controlling the intensity of the
ambient illumination, so you must do this entirely with the
value (V) slider.  Usually the V slider should be set about
one quarter of the way from the left.

                                                                        7-4

    The illumination setting can sometimes be used in place
of fill lighting, but if the illumination value is set too high,
images will seem flat and lifeless.  Too small a value will
make shaded faces look unnaturally dark.  The default value
that is set at program start-up is a good all-around value.

The sky

    You will have noticed a blue background in the images
you have created so far.  This background, although it is
called the sky, need not be blue.  Execute the menu
command WORLD SKY and you will see a color requester
pop up.  The SKY requester is similar to the
ILLUMINATION requester, but it has a couple of extra
gadgets.

    Unless it has been changed, the topmost gadget will
contain the word GRADUATED.  This gadget is a three-way
toggle.  Click on it a few times and watch it change from
GRADUATED to NONE, then to SOLID, repeating the
cycle as you continue to click.

    If you leave this gadget set to NONE, there will be no
sky, and the background will be black.  Notice that the color
swatch shows black, despite the settings of the sliders.
Now select SOLID, and see that the swatch now reflects the
color set by the sliders.  If the sliders are moved, the swatch
changes color normally.  If you click OK and make an
image, then the background color will be the one that you
have selected.

    Now select GRADUATED, and notice that an extra
border is added around part of the swatch's perimeter.  If the
border surrounds the top half of the swatch, the sliders only
change the color in that half.  Now click anywhere on the
swatch.  The border should jump from the top of the swatch
to the bottom, then vice versa if you click again.  This is a
special kind of toggle gadget.  By selecting which half of the
swatch is highlighted by the border, you can set up two
entirely different colors.  The upper color represents the sky

                                                                        7-5

color at the zenith, or directly overhead.  The lower color
represents the color at the horizon.

    If you make a picture with a GRADUATED sky and use
SNAPSHOT or PHOTO mode, the sky color will blend
smoothly between the ones that you have selected.  In
PAINTING and SKETCH mode, the color of the sky will
be the zenith color.

    As we have said, a GRADUATED sky blends the two
selected colors into each other.  In fact, some blending might
actually occur if you were to set the two colors to the same
value.  This is because the color sliders are more accurate
than the color resolution of the Amiga.  If the slider setting
falls between two usable values, Sculpt Animate 'dithers' the
colors to simulate the correct shade.

    Because a GRADUATED sky must be dithered anyway,
this should cause no problem.  If you select SOLID sky,
however, it will be assumed that you want no dithering, and
the closest available 'pure' color will be used for the whole
sky.

The ground

    If you wish to depict a scene in which objects are not
floating freely in space, but are sitting on or suspended near
the ground, then you must make a model of the ground.

    If the ground is to be flat, then a single triangular face
could be employed.  If it is a few hundred times bigger than
the scale of the other objects, it will seem to stretch off to
infinity.  This sort of ground has some disadvantages: for
one thing, there is the bother of constructing and placing the
ground; for another, this type of ground will often obscure
your objects in the SKETCH rendering mode (see imaging
modes, chapter 3).

    As a simpler alternative, you can use the ground plane
that is built into Sculpt Animate.  To use it, execute the
command WORLD GROUND.  A color requester will be

                                                                        7-6

invoked.  Like the sky color requester, it has a ground type
gadget near the top right.  By clicking on it, it can be
toggled between NONE, SOLID and CHECKERED.

    If NONE is selected, then no ground is produced.
Otherwise an infinite ground plane is generated that passes
through the Origin.  The Origin is the center of the Sculpt
Animate universe, and it is where the observer target is
initially placed.  If ground exists and it passes through the
Tri-View, it is displayed as a horizontal line in two of the
windows.  If you enable the ground but can't see it in a Tri-
View window, it is because the Tri-View 'box' is too far
above or below ground level.  Try expanding the Tri-View
until the ground comes into view.

                +---------------------------------------+
                |               +-----------+ +-----+   |
                |  GROUND TYPE: | CHECKERED | |.:.:.|   |
                |               +-----------+ +-----+   |
                |    +------------------------------+   |
                |  R |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  G |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  B |    |>                        |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  H ||>                            |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  S ||>                            |   |
                |    +------------------------------+   |
                |    +------------------------------+   |
                |  V |    |>                        |   |
                |    +------------------------------+   |
                |                                       |
                |               +-------+               |
                |               |       |               |
                |               |       |               |
                |               |       |               |
                |               |       |               |
                |  +--------+   |       |   +--------+  |
                |  | CANCEL |   |       |   |   OK   |  |
                |  +--------+   +-------+   +--------+  |
                |                                       |
                +---------------------------------------+

                        The GROUND Requester

    If you select a SOLID ground, then it will be uniformly
colored and you can use the sliders to pick a color.  If you
select CHECKERED, then the swatch divides into two and
you can select two colors, just as you did for the sky.  A
checkered ground plane is one where alternate squares on
the ground are different colors, like the squares on a chess

                                                                        7-7

board.  The ground will only be checkered in the HAM
imaging modes.  In the other solid modeling modes, the
ground will be the color of the top-half of the color swatch.

    The size of the square can be specified by clicking on
the small checkered icon just to the right of the word
CHECKERED.  This sets the size of each square to be the
same as the maximum dimension of the current Tri-View
'box'.  For instance, if you click this gadget when the Tri-
view is sized so that only a small portion of your object is
visible, then the checkers will be small in comparison to
your object.  If the object looks small in the Tri-View when
you click the gadget, then the checkers will be very large
relative to your object.

    In case you need to know, the center four-square of the
checker pattern will always be centered on the Origin.  The
top half of the color swatch will be used for the northwest
and southeast squares of this center block, the bottom half
for the northeast and southwest squares.

    Although a checkered ground plane has become
something of a cliche in computer generated images, it does
give the image more depth, and enhances the illusion that the
ground extends to infinity.  In addition, it adds interest to
scenes that contain mirrored objects, for the reflections of
the checkered ground make it easier for the eye an brain to
perceive the shape of a mirrored object.

    You can stretch the usefulness of a checkered ground
with a little creativity.  A red-and white checkerboard with
fairly small squares can look like a tablecloth, especially if
the observer is looking downwards.  Enormous squares
done in two earth-tone colors can suggest an agrarian plain.
Additional features, such as hills, etc., can be added as
objects placed in the background.

    When you use a checkerboard, it is often best to keep the
lamps fairly close to the subject, not much farther than the
observer.  This tends to darken the ground in the distance,
reducing odd effects that can occur where the checker
squares become very small.  On the other hand, sometimes it

                                                                        7-8

can add balance and interest to an image to place an extra
lamp off in the background, illuminating a patch of the
checkerboard where there would otherwise be an unbalanced
empty space.

                                                                        7-9

                                CHAPTER 8

                                 SPLINES

    Earlier we showed you how to create basic curves in
Sculpt Animate by placing individual vertices.  This chapter
describes a way by which you can take such a curve,
roughly sketched, and easily transform it into smooth,
sweeping curves.  With a few mouse clicks you will be able
to construct convincing profiles for aircraft and boats.
Curves generated this way can be modified and controlled
interactively.

Splines and knots

    Splines provide a way of creating and manipulating
smooth curves.  In the days before computers, when a
designer wished to generate a smooth curve, he used a thin
strip of wood (or metal or plastic) and bent it to produce the
desired shape.  The strip was called a spline.  Usually, the
designer would mark a few points, called knots, on his
paper, and bend the spline so that it passed through the
knots.  The spline defines the shape of the curve between
the knots.

    A mathematical simulation of a spline requires a little
calculus, but all the messy details can be left to the
computer.  Sculpt Animate only needs three commands to
work with splines: one command to make splines, one to
modify them, and one to erase them.  Although splines are
very simple to use, there are some rules that must be
followed, and since they are not at all obvious, you should
study the next section quite carefully.

    As we have seen, a curve may be represented by a
sequence of vertices that are joined by edges.  They are not
really curved at all, they are just a sequence of straight lines
segments.  If you use many segments, the approximation to
a true curve becomes quite good.  The curve tool can be

                                                                        8-1

used to construct a sequence of edges, or the sequence can
be built in a number of other ways using facilities we have
already seen.

    Having constructed a curve, you can make it a spline,
but first you must tell Sculpt Animate which vertices are to
become knots.  To do this, be sure that all other vertices in
the scene are deselected, then select a few vertices along the
curve you are working with.  The vertices you select will
usually be key locations along the curve--points that you
either don't want to move, or that you want adjacent vertices
to follow.

    Make sure that you have several unselected vertices
between adjacent selected vertices.  When the selected
vertices become knots, the unselected ones will 'snap' into a
smooth curve, and afterwards follow the knots wherever
they go.

    Now execute the EDIT DO MAKE SPLINE command.
If you have done everything correctly, the command will
subtly alter the curve you have laid out.  If a warning
message appears, you have probably selected vertices that do
not all lie on a single, unbroken curve.  If this happens no
other actions will be taken, so you can try again.

    If the spline command succeeds, the unselected vertices
on the spline curve will be re-aligned so they lie on a smooth
curve which passes through the knots, which should not
move.  Each knot will have a small arrow drawn on the
edges that connect to it.  This identifies the vertex as a knot,
even if it is not selected.

    By making the curve a spline, you have given it a
property of smoothness.  Until the spline is erased, anything
that you do with this curve will result in a smooth, flowing
transition from one knot to the next.  There is more than one
way to draw a curve through a set of points, so the spline
command picks one that follows a simple mathematical
formula.  You can exert quite a lot of influence over the
curve, though, if you do not like the one that was chosen for
you.

                                                                        8-2

    Let's try manipulating the spline some.  Deselect all but
one knot and use the grabber gadget to move the knot.  If
you watch closely, you will notice that the other knots do not
move, but the non-knot vertices between the moving knot
and the adjacent knots move so as to always lie on a smooth
curve.  Deselect the knot and select a non-knot vertex.  Now
try to move the vertex with the grabber tool and you will see
that the grabber has no effect on a non-knot vertex of a
spline.  This is because the position of a non-knot vertex is
solely determined by the positions of neighboring knots.

    This is one of the exceptions to the rule that only selected
vertices may be manipulated in Sculpt Animate.  In this case,
non-knot vertices, selected or not, may only be manipulated
by working with adjacent knots.

    Moving knots is the most fundamental way to manipulate
a spline.  Note that the spline does not have to lie in one
plane.  To see this, go to another Tri-View window and
move a knot.  you will see the spline twist into a third
dimension.  In Sculpt Animate, a spline is more like a piece
of wire than a curve drawn on a flat surface.  By
moving the knots, the spline can be bent into almost any
shape.

    There is one tricky part to manipulating a spline this
way.  If the spline is very smooth (that is, if it has a lot of
non-knot vertices), then it may be hard to select a knot by
itself without contracting the Tri-View to 'zoom in' on it.
Fortunately, this isn't necessary.  As long as you've selected
the one knot you want, selected non-knot vertices will just
follow along as usual.  This means you can use the Selector
tool to 'shotgun select' several vertices in the neighborhood
of the knot you want.

Slope and speed

    The exact shape of the spline between two knots is
determined by four parameters, two for each knot.  One pair
of parameters is called the slope and the other pair is called
the speed.  The slope at the knot is just the direction of the

                                                                        8-3

curve in the vicinity of the knot, in mathematics, this
direction is called the tangent.  Unless you take special
action, Sculpt Animate calculates a reasonable slope based
on the positions of the knots on either side

    To see how this works, do an ERASE ALL to clear the
Tri-View, and draw a curve with a dozen or so vertices.
Deselect them all and then select the two end vertices.  Make
a spline, as described above.  All the non-knot vertices will
align themselves uniformly between the knots.  With only
two knots, there is no information about the shape of the
curve that you would like, so Sculpt Animate generates the
simplest possible curve between the knots--a straight line.

        +--------------------------------------+
        |======================================|
        +--------------------------------------|
        |               MODIFY KNOT            |
        |                                      |
        |              +----------+            |
        |   Knot type: |  REGULAR |            |
        |              +----------+            |
        |              +----------+            |
        |   Side:      |  INWARD  |            |
        |              +----------+            |
        |              +----------+            |
        |   Slope:     |CALCULATED|            |
        |              +----------+            |
        |                                      |
        |                                      |
        |                SPEED                 |
        | +----------------------------------+ |
        | |                ||                | |
        | +----------------------------------+ |
        |                                      |
        |   +--------+            +--------+   |
        |   | CANCEL |            |   OK   |   |
        |   +--------+            +--------+   |
        |                                      |
        +--------------------------------------+

                The Modify Knot Requester

    Now move the cursor to one of the knots and execute the
menu command EDIT MODIFY INDICATED KNOT.  A
requester with the title MODIFY KNOT will pop up.  The
requester has a drag bar, so you can move it out of the way
if it hides the spline you are working on.  In the requester,
you should see a gadget marked CALCULATED, beside the
title 'Slope:'.  Click on this gadget, and it will toggle

                                                                        8-4

between CALCULATED and SPECIFIED.  Leave the
gadget in the SPECIFIED state, and notice that a yellow
arrow has now been drawn at the position of the knot.

    The rotate gadgets in each window now have a special
purpose.  Instead of rotating selected vertices, they rotate the
yellow arrow, which represents the slope of the knot.
Rotate the arrow and notice that the curve between the knots
deforms so that its tangent always matches the slope of the
knot.

    By switching to another Tri-View window, and using
the rotate gadgets, you can point the slope in any direction
and the curve will follow.  If you click the slope gadget, so
that it is in the CALCULATED state, the curve will snap
back to correspond to the slope calculated from the positions
of the nearby knots.  The slope that you constructed is still
remembered for the time being, in case you wish to return
the knot to its SPECIFIED state later in this session.  Only
SPECIFIED knot states are saved with the scene, though.

    When we manipulate a knot's slope, it is as though we
were twisting a draftsman's wooden spline at one of the
knots.  Real splines would not long survive such treatment,
nor do real draftsmen have surplus hands to apple torque at
each knot, so our mathematical spline has creative
advantages over its real-world counterpart.

    The other control that you have over a knot is its 'speed'.
This is set by the slider control near the bottom of the
MODIFY KNOT requester.  To best understand how this
parameter works, specify the slope of the knot you've been
working with so it's at an angle of about 45 degrees to the
line between the knots.  Now just move the speed slider and
see what happens.  Each time you release the slider knob,
the spline will be re-drawn.

    With large values of speed, the spline will seem to shoot
out a long way before being influenced by the other knot.
Small values of speed will cause the spline to quickly
forget about its initial slope and move towards the other
knot.  Also notice that the non-knot vertices get farther apart
as the speed increases, and closer together as it decreases.

                                                                        8-5

    When you have finished manipulating the knot, you can
either click on the OK gadget to accept its new settings, or
click the CANCEL gadget to undo your manipulations.  In
either case, the requester will vanish, and the rotate gadgets
will resume their normal operation.

    If you make a spline with several knots and set the speed
parameter for each knot to zero (the leftmost position for
each slider).  Then the non-knot vertices will move to lie on
straight line segments between the knots.  Try it.  Although
splines are usually thought of as smooth curves, they can be
made quite angular.

    Now go back and set the speed for each knot to its
maximum value, and you will see that the spline shoots
away from each knot with such force that it may even
perform a loop before returning to the next knot.  Quite
baroque curves can be constructed in this way.  Remember
what they look like, you never know when they might be
needed.

    We can compute this operation to the use of a wooden
spline.  Increasing the speed at a knot is like making the
spline stiffer at that point, while reducing the speed softens
the spline locally.  Our simulated spline has far outstripped
the abilities of any real spline.

    Although it is tempting to scatter many knots throughout
a curve, the power of Sculpt Animate's splines is best
realized if you use very few knots.  If you go back to the
example spline with only two knots, you will find that many
very graceful curves can be created simply by adjusting their
speeds and slopes.

    In chapter 10 we will see how any 3D curve, including
spline curves, may be used as a path to describe motion.  In
this use, each vertex of the curve represents a location in
time and space.  The 'speed' of an object following the curve
will be directly proportional to the distance between vertices.

    You should remember that this interpretation of the word
'speed' differs slightly from the 'speed' of a knot.  While it
is true that increasing a knot's speed generally moves the

                                                                        8-6

adjacent vertices apart, the effect is local.  The distance
between vertices also depends on the speed of adjacent
knots, and on the number of non-knot vertices between
knots.  Each of these factors will figure into the perceived
velocity of the animated object.

Cusps

    In mathematics, a cusp is a point where two curves meet
with equal and opposite slopes, as in the horns of a crescent
moon.  In general usage, a cusp can refer to anything pointy
looking.  In Sculpt Animate, we will use a looser definition
and apply the word to a place where two curves meet, but do
not share a tangent.

    To see how this applies to splines, create a spline with at
least three knots, set the cursor on one of the interior knots,
then call up the MODIFY KNOT requester.  Look at the
gadget labeled 'Knot type:'.  As you may have noticed on
other knots we have worked with, this knot's type is
REGULAR.  The 'type' gadget is a toggle gadget which
toggles between REGULAR and CUSP -- set it to CUSP.

    When the knot is made a cusp, the gadget labeled 'Side:'
will become effective.  This is another toggle gadget that has
two states, INWARD and OUTWARD.  These states refer to
the two arrows that mark the knot.  One points inward,
towards the knot, and the other outward, away from the
knot.  By toggling the Side gadget you can pick the side you
want to manipulate.  The side of the slope arrow that you can
manipulate will be shown in yellow, the side that is shown
in purple will not move.

    When a knot is made into a cusp, it is split in two, so to
speak.  Each side of the knot affects the non-knot vertices on
that side, but has no effect on the other side.  This means
that the knot suddenly has two slopes and two speeds, one
set for each side.  A cusp is like a point where the
draftsman's wooden spline has been snapped and joined by
a hinge.  Use a cusp when you need to break up an otherwise
smooth curve with an angle or corner.

                                                                        8-7

Using splines

    By now you have probably thought of several uses for
splines.  If you need to build an object with smooth curves,
a spline will ensure that the vertices are placed along a
convincingly smooth shape.  If your hand hobbles while
you use the Curve Tool, the wobbles will find their way into
objects that you Spin or Extrude from the curve.  Picking a
few strategically placed knots and creating a spline will even
out all the wobbles.

    If you want to modify a curve, it's much easier to grab a
knot or two and move them, rather than have to individually
move a dozen or more vertices and try to make them represent a
smooth curve.  Of course, the trade off is that non-knot
vertices of a spline can only be moved by moving the knots.

    If all the knots of a spline are selected, then the grabber
will move the spline all at once, without changing its shape.
The rotate gadgets may also be used freely on splines, and
on sections of splines.

    If you ever need to locate the knots of a spline, point the
cursor at any vertex on the spline, and execute the command
EDIT SELECT INDICATED SPLINE and each knot on the
spline will be selected.

    After you have built the curve that you need, it is a good
idea to erase the underlying spline.  Just move the cursor to
one of the vertices of a spline and execute the command
EDIT ERASE INDICATED SPLINE.  The spline will be
removed, but its vertices will remain.  The vertices can now
be manipulated in any of the usual ways.  A spline uses up a
certain amount of memory and it also slows down the
refresh speed of the Tri-View, so once you are through
manipulating the spline, it should be erased.

    Splines can also be made that are closed loops.  Create
them in the usual way.  For example, draw a square with the
curve tool.  Then use the EDIT DO SUBDIVIDE menu
command a few times so that you have several vertices along
each side.  Deselect all the vertices, and select only the
corner vertices as knots.  Then execute the EDIT DO MAKE

                                                                        8-8

SPLINE command and you should have a fairly tolerable
approximation to a circle.  Experiment with the speed
parameters, and you will find that you can make the circle
slowly revert to a square again.

An example: a gearwheel

    Suppose you wished to make a convincing model of a
gearwheel, you could use splines to make the job much
simpler.  First clear the Tri-View, and make the Tri-View
windows large with the command EDIT DO MAKE TRI-
VIEW BIG.

    We are going to make a twelve tooth gear wheel, using
eight vertices per tooth.  In the west window add a circle
with 96 subdivisions.  Carefully select every fourth vertex of
the circle.  As a check, make sure there are three unselected
vertices between every two selected ones, especially between
the last and first vertices that you selected.

    Execute the command EDIT DO MAKE SPLINE.  You
now have a 96 vertex circular spline, with 24 knots (all the
knots are selected).  Now deselect every other knot, so only
twelve vertices remain selected.

    Execute the command EDIT DO EXPAND and make
sure that the center of expansion is either CENTER or
CENTROID.  Move the upper slider a small distance to the
left and watch a gearwheel shape emerge.  When you are
satisfied with the shape, leave the requester by clicking OK.

    Move the cursor to any vertex and execute the command
EDIT ERASE INDICATED SPLINE, because we no longer
need to use the properties of the spline.  You now have the
profile outline of a gearwheel.  Save this outline to disk--you
will need an unfilled copy later.

    Now the gear wheel profile may be filled with triangles,
to make it a visible surface.  If you were to select the
gearwheel's profile and use the EDIT DO FILL command,
the time to fill in a 96 vertex curve would be about half an

                                                                        8-9

hour, so it might be quicker to use the edge maker tool.
Alternatively, and perhaps less tedious, you can make a
number of edges manually, to divide the outline into a dozen
or so regions, the select each region in turn and use the
FILL command on it.

    In any case, once you have filled the profile, save the
filled version to a separate disk file, being sure not to
overwrite the unfilled copy.

    You could now simply extrude the filled outline to create
a solid gearwheel, but this step has two disadvantages.
First, this will leave the back side of the gearwheel open.
This is actually an advantage if it will never be seen, since it
saves memory and speeds calculation, but it could be
annoying if the back side needs to be there.

    The second disadvantage only arises if you intend to use
smoothing.  There are two things that can confuse the Phong
smoothing algorithm: flat surfaces made up of many faces,
and right-angle corners (see chapter 4).  If you envision our
extruded gearwheel, you'll see that it has both of these problems!
If you wish to use smoothing on the curved portions of the
teeth, you must somehow separate the gearwheel's edge
from its flat surfaces.

    One way to do this is to form the gear wheel from three
unconnected parts: the two flat faces and the curved portion
that joins them along the edge.  This allows you to turn
smoothing on only for the curved portion.

    To do this, first clear the Tri-View and load the
gearwheel profile that you saved earlier.  Use MODIFY
FACES to turn on smoothing, then extrude the profile.  Add
a copy of the gearwheel's filled surface with the PROJECT
LOAD OBJECT command.  Use the Grabber to move the
face into place at the front of the gear wheel.  Load a second
copy of the filled outline and position is as the back surface.

    Select the flat surfaces and use MODIFY FACES to turn
their smoothing OFF.  The gearwheel is complete!

                                                                        8-10

                                CHAPTER 9

                          WHEELS WITHIN WHEELS

    Whenever you must deal with a complicated system, it is
always easier to break down the larger problems into a
number of smaller, simpler ones.  As we saw in chapter 6, it
can be very convenient to think of a complex object as a
collection of simpler parts.  When the object is completed,
you can connect the parts together and forget about them,
dealing with the object as a single item again.

    But what if we want to deal with an object as a whole at
some times, and as a collection of parts at others?  As we
begin to animate objects in subsequent chapters, you will see
ample need for this ability.

    Sculpt Animate allows you to organize the objects of a
scene, the parts of the objects, the parts of the parts, and so
forth, into a hierarchy.  At any given time you can deal with
the level in the hierarchy that suits your needs.  In later
chapters you will see that, as with objects, object motions
may also be placed in the hierarchy.

Hierarchies of objects

    A hierarchy is a structure in which each member has a
well defined level.  Except for the uppermost level of the
hierarchy, each member is subordinate to one superior
member.  On the other hand, each member may directly
control one or more members at the next lower level.

    This ordering is similar to that of a branch of the armed
services, or a large corporation.  The exception is that in
these 'real world' hierarchies, lower members are often
subordinate to any superior, not just one.

                                                                        9-1

    Another everyday structure that takes the form of a
hierarchy is a family tree.  We will borrow some familiar
terms like 'parentage' and 'offspring' when we describe the
hierarchical structure used in Sculpt Animate.

    The object structure of Sculpt Animate is imposed by
giving names to groups of vertices.  The names form a
hierarchy.  For the time being we will be discussing this
hierarchical structure 'on paper'.  The next section will
discuss the mechanics of constructing and using such a
structure.

    Suppose that we have constructed models of several
people, Fred, Joe and Bill for example.  It would be
convenient to be able to treat the model of each person as a
single entity, even though each may be constructed from
several unconnected elements.  It is as though we could
issue the command 'SELECT Bill', and have all the vertices
of the model Bill be selected.  Bill could now be grabbed
and moved to a new location, or rotated and expanded.

    For many cases, this is quite enough.  If, for instance,
Bill were not a human figure, but actually one of three red
regions on the hull of a flying saucer, then having a name
tagged onto Bill's vertices permits you to select them
independently, without having to care what they're
connected to.  This sort of ad hoc, piecemeal, naming of
things can be very helpful if you are just modeling objects.
More complex organization may not be needed.

    But, as its name suggests, a big part of Sculpt Animate is
animation.  Bill, is more than likely, a human figure; or at
least something that moves.  If simple naming were all there
was to the scene's hierarchy, Bill would be like a mannequin
with no moving parts.  In the hierarchy, though, we can
arrange his parts into a series of levels, with the whole lot
being named 'Bill'.  The idea is to be able to select some of
Bill's parts independently, or select Bill all at once.

    Lets say we want to be able to select just Bill's left arm.
It wouldn't be enough just to rename those vertices as
'leftarm,' because they would no longer be selected when

                                                                        9-2

we select Bill.  We need to have a way to name the vertices
'Bill's left arm.'

    In Sculpt Animate parlance, this can be done by naming
the vertices 'Bill+leftarm.'  Assuming that we had deselected
all vertices, the command "SELECT Bill+leftarm" would
then cause all the vertices of Bill's left arm to be selected.
By placing the cursor at Bill's left shoulder, the rotate
gadgets could be used to raise Bill's hand, the first step in an
animated salute, for example.

    This suggests that we could decompose Bill into several
elements, such as

        Bill+leftarm
        Bill+rightarm
        Bill+head
        Bill+torso
        Bill+leftleg
        Bill+rightleg

    Each element could be further decomposed, for example

        Bill+leftarm+upper
        Bill+leftarm+lower
        Bill+leftarm+hand

    The only limit in our subdivision is the amount of detail
in the model of Bill.  We can continue.

        Bill+leftarm+hand+finger1
        Bill+leftarm+hand+finger2
        Bill+leftarm+hand+finger3
        Bill+leftarm+hand+finger4
        Bill+leftarm+hand+thumb

    If we compare the structure of Bill to a family tree, we
can regard the name 'Bill' as the founding father with
offspring 'head', 'leftarm', etc.  The name 'leftarm'

                                                                        9-3

begets 'upper', 'lower' and 'hand', and 'hand' produces
five offspring in the fourth generation, including 'thumb'.

    A drawback of this organization is that here may be
combinations that we wish to select, like both thumbs, or all
fingers and all toes, that are not accessible with a single
command.  When you plan your hierarchical structure, you
should bear in mind what combinations are going to be used
most often, and design the hierarchy accordingly.

    Another major factor in the design of the hierarchy is
motion.  Although we have only touched on the subject so
far, the primary use for a scene's hierarchy will probably be
to animate objects.  In later chapters, you will learn how
motion fits into the hierarchy, but first you have to learn how
to construct the hierarchy itself!

Building a hierarchy

    As you have probably guessed, there is a facility in
Sculpt Animate for building a hierarchy of names.  To see it,
execute the menu command EDIT NAME SELECTED
VERTICES.

    Although this command is designed to supply a name to
a group of selected vertices, it also lets you build a hierarchy
of names.  The requester that pops up has a column of 9
slots.  This represents the 'current' generation of the
hierarchy.

    Because we have not entered any names, all the slots are
empty.  To the left of the current generations is a long
horizontal box titled 'Parentage', which is also empty.
When the requester comes up, the box titled 'Add name:'
will have a cursor in it, which means that it is ready for you
to begin typing in the first name of the current generation.
For starters, type in 'Bill'.  When you press RETURN, the
name will be transferred to the center of the current
generation.

                                                                        9-4

    Now type in 'Fred', 'Joe', etc.  As you type in more
names, you will notice that they are entered into the current
generation in alphabetical order, and the name is always
entered into the center slot.  You may wonder just what it is
that you are naming.  As of now, nothing.  You are simply
entering names into the hierarchy.  You may enter a number
of names all at once, then go back at your leisure and assign
them to vertices.

        +------------------------------------------------------------+
        |============================================================|
        +------------------------------------------------------------|
        |               NAME SELECTED VERTICES                       |
        |                                                            |
        |          +------------+  +--+ +--------------+             |
        | Add name:|            |  |/\| |              |             |
        |          +------------+  +--+ +--------------+             |
        |                          |  | |              |             |
        |  +---+  +----+  +-----+  |  | +--------------+             |
        |  |CUT|  |COPY|  |PASTE|  |==| |              |             |
        |  +---+  +----+  +-----+  |  | +--------------+             |
        |        Parentage         |  | |Bill          |             |
        | +---------------------+  |  | +--------------+ +---------+ |
        | |                     |  |  | |Etc           | |OFFSPRING| |
        | +---------------------+  |  | +--------------+ +---------+ |
        |                          |  | |Fred          |             |
        | +------+                 |==| +--------------+             |
        | |RENAME|                 |  | |Joe           |             |
        | +------+                 |  | +--------------+             |
        | +----------+             |  | |              |             |
        | |ERASE NAME|             |  | +--------------+             |
        | +----------+             |  | |              |             |
        | +------+                 +--+ +--------------+ +--------+  |
        | |CANCEL|                 |\/|                  |   OK   |  |
        | +------+                 +--+                  +--------+  |
        |                                                            |
        +------------------------------------------------------------+

                    The Name Selected Vertices Requester

    If you persist in adding names, a scroll bar will become
active, so that you can move the list up and down, moving
any name of the current generation into the center slot.  If the
name you want is among the nine items that are visible, you
can quickly move it to the center slot by clicking on it with
the left mouse button.

    By now you will have realized that his center slot has
special significance.  If you were to terminate this requester
by clicking it on the OK gadget, any selected vertices would be
given the name in the center slot.  Call this name the
current name.

                                                                        9-5

    Now let's create a new generation.  To start, click on the
name Bill, or use the scroll bar to make Bill the current
name.  Next click on the gadget to the right, the one called
OFFSPRING.  Two things will happen.  First, the column
of names representing the current generation will be cleared.
This is because we are looking at Bill's offspring, and he
doesn't have any yet.  The second thing to notice is that the
name 'Bill appears in the box titled 'Parentage:'.  Bill is the
parent of the yet to be created offspring.

    To give Bill his 'offspring', add the names 'leftarm',
'rightarm', 'leftleg', 'rightleg', 'torso' and 'head'.  Click on
'leftarm' and it will become the current name, or to be exact,
the current name will be 'Bill+leftarm'.  Click on the
OFFSPRING gadget and we are ready to add the third
generation: 'upper', 'lower' and 'hand'.  The parentage box
will show 'Bill+leftarm'.  Continue in this way until you
lose patience, or Bill's left arm structure is defined all the
way to his thumb and fingers.

    If you wish to backtrack to an earlier generation, click on
the Parentage box.  You are never able to add things to this
box, but clicking on it will transfer you to the next older
generation of names.  If the list of ancestors becomes too
large to fit in the Parentage box, you can still continue, but
only the most recent ancestors will be displayed and three
periods (...) will be displayed to show that the parentage list
is not complete.

    You have just constructed an elaborate hierarchy.  As
you create hierarchies of your own design, you should
remember these important, if minor, restrictions:

        1)  The names that you use cannot be more than 10
            characters long (that is the most the 'Add
            name:' gadget has room for).

        2)  You may use upper and lower case letters, but the
            name will be treated as though it was all in upper
            case, for the purpose of maintaining the current
            generation list in alphabetical order.

                                                                        9-6

        3)  The same name may not be used more than once
            as the offspring of the same parent.  Thus Bill
            can only have one 'leftarm' on any one level, but
            Bill and Joe can each have a 'leftarm' of their
            own.

        4)  If the name begins with a digit (0 through 9),
            strange things may happen.  Avoid using names
            that start with a digit until you learn the
            ramifications of doing so (in chapter 12).

        5)  Do not use any characters except letters, digits,
            period (.), underscore (_), minus (-), or sharp
            (#).

        6)  The object hierarchy may be up to 16 generations
            deep but you will probably never need more
            than 5 or 6 generations.

        7)  A name may have up to 255 offspring, which
            should suffice for the most prolific name.

        8)  Avoid using the names LOCATION and
            TARGET, these names are reserved so that you
            can refer to the observer's location and target for
            animation purposes.

    If you break these rules, the name will usually not be
added to the current generation of names.  The exceptions
are rules 4 and 8.

    Although the same name cannot appear twice in the same
level with the same parentage (rule 3), the same name can be
used on different levels of a branch, for instance, Bill's
upper and lower arm may both be named 'arm' in this
fashion: 'Bill+leftside+arm+arm'.  The names are on
different levels, so they don't conflict.  The name 'leftside'
in this example might not even name any vertices by itself.
Such a 'null' name can be used as an attachment point for
grouping other named vertices.

                                                                        9-7

    If you make a mistake entering names, the current name
can be erased with the ERASE NAME gadget, provided that
the name has no offspring.  If it has, erase all offspring
first.  Any vertices that have been named by the erased name
become unnamed 'free agents'.

    At any time you can leave the requester by clicking on
the OK or CANCEL gadget.  The oK gadget will assign the
current name to any selected vertices.  The CANCEL gadget
allows you to leave the requester without assigning any
name to the vertices, but it will not destroy any changes you
have made to the hierarchy.

    It is possible to assign a name to vertices that have
already been named.  If this happens, the old name will no
longer apply to the renamed vertices, since a particular vertex
can have only one name.  Suppose that the vertices of Bill's
left thumb were selected, and you named them 'Joe', then no
vertices would respond to the name
'Bill+leftarm+hand+thumb'.

    In our example, we have entered several names into the
hierarchy that do not as yet, have vertices assigned to them.
When you are building an object with a specific plan in
mind, it works well to lay out the hierarchy beforehand and
enter it all at once.  The vertices of your objects may be
selected and assigned names afterward.  It is just as well in
some cases to create your objects or parts of objects first,
then assign names to the various parts.  You will soon find
which approach suits your style most in various situations.

    If you have constructed your object so that it's parts are
not connected by edges, it may be easier not to select vertices
for naming, but to simply indicate the object you wish to
name with the cursor and use the command 'EDIT NAME
CONNECTED VERTICES.  This command is similar to
EDIT NAME SELECTED VERTICES except that it operates
on vertices that are connected to the indicated vertex.

                                                                        9-8

Using an object hierarchy

    The object hierarchy can be used to select, deselect and
erase groups of vertices by name.

    Going back to our example hierarchy, you may select
Bill's left thumb executing the menu command EDIT
SELECT NAMED VERTICES.  A requester very similar to
the NAME SELECTED VERTICES will pop up.  Instead of
the 'Add name:' and ERASE NAME gadgets, there are
SELECT and DESELECT gadgets.

    To use this requester, you must first pick a name.  Do
this by clicking on a current generation, Parentage, or
OFFSPRING gadget.  When the current name is correct,
press the OK button, and the selection will be made as you
leave the requester.

    You don't have to leave the requester every time you
want to select something.  Instead, you may press the
SELECT gadget, which immediately selects the vertices
name by the current name, as though you had clicked OK
and executed the command again.  This leaves you free to
change the current name and select something else.

    As a matter of convenience, there is also a DESELECT
gadget which allows you to deselect vertices without leaving
the requester.  For example you could select all four of Bill's
left fingers (and his palm, if he has one) by choosing the
name Bill+leftarm+hand and clicking on SELECT.  This
also selects Bill's thumb, though, so next you can click
OFFSPRING, then 'thumb' to make it the current name, and
then click DESELECT.

    The SELECT and DESELECT gadgets take effect
immediately.  If you press on the CANCEL gadget to leave
the requester any selections or deselections that you have
made with them will be retained.  When you click OK to
leave, vertices with the current name will also be selected.

    If you try to select vertices that are already selected, the
screen will flash to tell you that your request had no effect.

                                                                        9-9

    The menu command EDIT DESELECT NAMED
VERTICES calls up a requester that works the same as it's
counterpart, except that the OK gadget causes vertices with
the current name to be deselected instead of selected.  It also
has both SELECT and DESELECT gadgets.

    The command EDIT ERASE NAMED VERTICES
invokes a requester called ERASE NAMED VERTICES.  If
you click OK in this requester, the vertices named by the
current name, as well as those named by all its offspring,
will be erased.

    The ERASE NAMED VERTICES requester has two
special purpose gadgets: ERASE VERTICES and ERASE
NAME.  ERASE VERTICES has the same effect as clicking
OK and then re-invoking the requester.  ERASE NAME
erases the current name from the hierarchy, unless the name
has offspring.  To erase a name with offspring, erase all the
offspring names first.

    If you wish to erase a name and its vertices, be sure to
erase the vertices first.  Once the name is erased, you will
have to select the vertices by some other means before you
can erase them.

Editing the hierarchy

    Mistakes can happen and it is important to be able to
easily correct them.  If you wish to alter a scene's hierarchy,
call up any of the EDIT NAME requesters, such as EDIT
NAME SELECTED VERTICES.  In addition to their normal
functions, these requesters permit you to re-order and
otherwise edit the hierarchy.

    For instance, if you want to change the name of a
hierarchy element, select the name that you wish to change
and press the RENAME button.  A requester will pop up to
let you type in a new name to replace the current name.

    These requesters also have CUT, PASTE and COPY
buttons.  The command CUT will extract the current name

                                                                        9-10

and its vertices from the hierarchy, along with all its
offspring and all the vertices they name.  These items are
stored in a temporary location in RAM.

    The COPY button works in a similar fashion, except that
the items are only copied into temporary storage, and the
original vertices and names are unchanged.

    The PASTE gadget may be used to retrieve items that
have been stored with COPY or CUT.  When PASTE is
clicked, the name that was current when the last CUT or
COPY occurred will be entered into the current level of the
hierarchy.  All that name's vertices will also be entered, as
well as it's offspring and their vertices.  Note that the copied
vertices will lie in the same location as the original vertices,
so you will probably want to select these vertices, grab
them, and move them somewhere else.

    The hierarchy action of CUT and PASTE should become
clear if we use these commands to supply an object named
'Joe' with a left arm copied from 'Bill'.  First issue an EDIT
NAME SELECTED VERTICES menu command.  Make the
name Bill+leftarm the current name and click on COPY.  The
vertices named Bill+leftarm will be copied to temporary
RAM storage, along with the matching hierarchy fragment,
something like this:

                                          +----- finger1
                                          |
        leftarm -----+---- hand ----------+----- finger2
                     |                    |
                     +---- upper          +----- finger3
                     |                    |
                     +---- lower          +----- finger 4
                                          |
                                          +----- thumb

    Now move up a level and select or type in the name
'Joe', then click on the OFFSPRING gadget.  Currently Joe
does not have any offspring, so all the current generation
slots should be clear.  Now press the PASTE gadget.  You
will notice that Joe now has the hierarchy structure of a left

                                                                        9-11

arm.  If Bill's left arm actually contained vertices, these have
been duplicated.

    When you perform a PASTE, it is possible that the item
you want to paste will have the same name as another item in
the same level of the hierarchy.  If this happens, you will be
asked if you want Sculpt Animate to merge the two items.  If
you say no, a new name will be generated for the new item,
which you can rename later if you wish.

    If an item is passed farther down in the hierarchy than it
originated, it is possible that it's structure might extend past
the sixteen level limit.  If this occurs the hierarchy segment
will be truncated to fit.  New vertices that would have been
named by the truncated levels will be unnamed.

Loading and saving named objects

    Two more commands serve to round out the object
hierarchy system.  The menu command PROJECT SAVE
NAMED OBJECT, invokes a simplified version of the
standard hierarchy requester.  After you have selected a
name from the hierarchy by traversing the family tree, you
can press the OK gadget to save the currently named object
as a scene file.  A standard file requester will appear to let
you enter or choose a name for the scene, just as if you had
issued the PROJECT SAVE OBJECT command.  The part
of the hierarchy that corresponds to the object will also be
saved in the scene file, just as it would be stored by CUT or
COPY.

    The complementary command, PROJECT LOAD
NAMED OBJECT calls up a requester similar to the NAME
SELECTED VERTICES requester.  You can use the usual
gadgets to modify and traverse the hierarchy.  When you
select a particular level in the hierarchy and click on the OK
gadget, you will first be prompted for the name of the scene
file, and then the object will be loaded.  If the scene file
contains hierarchy information, for example if it was
produced by the PROJECT SAVE NAMED OBJECT
command, then the hierarchy will be merged into the current

                                                                        9-12

hierarchy at the selected level.  It doesn't matter which
member of the current generation was chosen, the loaded
object's hierarchy will just be loaded into the selected level.

                                                                        9-13

                                CHAPTER 10

                               MOTION PATHS

    The last chapter hinted that a scene's hierarchy may be
used to give an object motion. This chapter explains how
motion can be created and manipulated in the Tri-View as a
special sort of object called a path. Paths are an instrumental
part of global animations, one of Sculpt Animate's two
fundamental types of animation, both of which are described
in the next chapter.

Paths

    We have seen that, in Sculpt Animate, a set of vertices
linked by edges can be used to represent a curve in three
dimensional space. We have also seen how splines are
power tools for creating smooth curves.

    Sculpt Animate also supports a slightly different entity
called a Path. A path is used to represent the motion of a
point that moves through space. If you regard time as a
fourth dimension, then a path is a 4 dimensional curve. This
may sound rather frightening. Fortunately, paths have a
simple representation in Sculpt Animate, and no
mathematical knowledge is required to use or manipulate
them.

    Instead of the abstract concept of a point moving through
space, let us take a concrete example. Suppose we wish to
make an animation of a man running across the Sahara
desert. Perhaps through derangement caused by lack of
water, he does not run in a straight line but in irregular loops
and wobbles. What's more, he not only moves in the
horizontal directions, but also up and down the sides of the
desert's sand dunes. He is a living model of three
dimensional motion.

                                                                        10-1

    His footsteps in the sand leave evidence of where he has
been. If we assume that he is running at a steady pace, say
one pace per second, then by counting footsteps we know
when he was at a particular place. Footprint number 60
must have been made one minute after he started running.
His motion has defined a clear, unambiguous path.

    In Sculpt Animate, we can mimic this sort of path by
placing a vertex at each location, or 'footstep', and link
adjacent steps with an edge. This will just be a curve in
space, but we can interpret it as a path if we assume that each
vertex fixes the location of our modeled man at a particular
time. While the real man's hapless wanderings apparently
created his path, our imaginary man will follow the path we
create for him.

    Once we have described the path for our man, or any
moving object, Sculpt Animate will create a sequence of
images, similar to the ones we have been creating all along.
Each image shows the animated object in a slightly different
place along the path. When the images are shown in rapid
sequence (many times per second), the object seems to move
along the path.

    Each of these images is called a 'frame' in animator's
parlance. Instead of dividing up our paths by footsteps, we
say that each vertex on a path represents the animated
object's location in a particular frame of the animation. For
smooth motion, of course, there would probably be more
than one vertex (i.e., frame) for each step along a running
man's path.

Creating paths

    We have already seen that it is easy to create a curve in
Sculpt Animate. A curve is not quite the same thing as a
path, however. The primary difference is that a path must
have an unambiguous starting point. A closed curve path
(like a circle) could start at any vertex, and go either direction
around the curve. An open curve path could start at either
end.

                                                                        10-2

    Another important rule for paths is that they must never
fork. The reason is clear enough, if the vertex defining one
location of the path has two edges leading away from it,
which way is the program going to move the object?

    Because of these considerations, we need to tell Sculpt
Animate that a curve is to be a path, where it starts, and -- in
the case of closed loops -- which way it leads.

    If the curve is open (has two ends), you can do this
simply by moving the cursor to one of its end vertices and
executing the command EDIT DO MAKE PATH. The
cursor indicates the beginning of the path, where the object
will be placed in the animation's first frame.

    If the path is a closed loop or circle, then you need to
pick a direction for the path, as well as indicating the first
vertex. This is done by first executing a DESELECT ALL,
then selecting the vertex that will be the second location in
the path. When this is done you can indicate the first vertex
and issue the command EDIT DO MAKE PATH as usual.

    Sculpt Animate will examine the indicated curve to make
sure it is suitable for use as a path. If it is not, the program
will display a message telling you why, and nothing else will
happen. If the curve is suitable, a small arrow will be drawn
halfway between its first and second vertices, to show you
that it has, indeed, been made a path.

    Except for memory, there is no practical limit to the
number of paths you may create. Later in this chapter, you
will see how to tell Sculpt Animate which path a particular
object is to follow. You will also see how the path an object
follows may be attached to yet another path, so that very
complex movements may be described.

    If you ever wish to erase a path, you may do so by
erasing its vertices. If you want to erase the path, but retain
its vertices and edges, indicate any vertex on the path and
issue the command EDIT ERASE INDICATED PATH.

                                                                        10-3

    If you want to see if a curve is a path, but don't want to
bother looking for its little arrow, indicate a vertex on the
curve and call the command EDIT SELECTED INDICATED
PATH. If the curve is a path, its vertices will be selected. If
not, a message will be displayed to tell you so.

Tumbling

    The last section told you how to create a path to describe
the motion of an animated object. The next section will tell
you how to make the object follow the path. This section
deals with an important detail which lies between these two
problems: how will the object be oriented as it follows the
path?

    Let's go back to our example of the running man.
Ignoring for the moment the rather difficult problem of leg
and arm motion, let's look at how the man should position
his body as he runs. For one thing, it is obvious that he will
always face more or less in the direction he is running.
Furthermore, he will probably pitch to one side or the other
when he turns. Finally, most people tilt forward somewhat
as they run -- more or less so, perhaps, when climbing or
descending a sand dune.

    If you were to attach our imaginary man to a path created
using just the techniques of the last section, this is not the
sort of motion you would see in the resulting animation.
Rather, the man would slide blindly along the path, always
facing in the same direction he faced when he was
constructed. This is because the program has no idea what a
man is, or how he runs -- if it did, it would be a much more
complex program indeed!

    Rather than trying to guess how the objects you create
will move, Sculpt Animate simply allows you to specify an
object orientation for each vertex along the path. This
orientation is called the 'tumble' for that location. When an
object follows a path, it orients itself according to the tumble
setting for each vertex.

                                                                        10-4

    You can set the part of the object about which it will
tumble (see the 'Local Origin' section, later in this chapter),
so you have complete control over the object's motion.

    If you specify the tumble for only a few vertices, Sculpt
Animate can often guess the correct tumble for the ones in-
between. We'll speak more of this later in this section.

 !==========================================!
 !==========================================!
 !                                          !
 !             MODIFY TUMBLE                !
 !                                          !
 !            !--------------!              !
 !            !  MATCH LAST  !              !
 !            !--------------!              !
 !     Method:!--------------!              !
 !            ! INTERPOLATED !              !
 !            !--------------!              !
 !    Move to:!----------!  !------!        !
 !            ! PREVIOUS !  ! NEXT !        !
 !            !----------!  !------!        !
 !  !-----------!       !-----------!       !
 !  !  CANCEL   !       !    OK     !       !
 !  !-----------!       !-----------!       !
 !==========================================!
 !==========================================!

    To specify the tumble setting for a vertex of a path, first
move the cursor to the vertex and execute the menu
command EDIT MODIFY INDICATED TUMBLE. This
command brings up a requester titled 'MODIFY
INDICATED TUMBLE'. Lid the MODIFY INDICATED
KNOT requester, this one also has a drag bar on the top so
you can move it around as needed.

    When the requester comes up, the indicated vertex will
become centered in the Tri-View, and three brightly colored
lines will be shown extending from it. These lines represent
the Tumble Axes for that vertex of the path.

                                                                        10-5

    The first time you call up the requester, one line will be
pointing East, one will be pointing North and one will be
pointing upwards -- so that only two of the lines are visible in
any one window. At this time, the lines all seem to have the
same length on the screen.

    Let us call these liens the East Tumble Axis, the North
Tumble Axis and the Up Tumble Axis, respectively. Note
that the East Tumble Axis is yellow, the North Tumble Axis
is white and the Up Tumble Axis is purple. You should
remember which color corresponds to each direction.

    As an aid to memory, you can paint your right index
finger yellow, your middle finger white and your thumb
purple. With a little contortion you can extend the two
painted fingers and the tumble so that each is at right angles
to the other. If you keep your thumb upright and point East
with your index finger, you middle finger will be pointed
North. Just like the Tumble Axes.

                         Up
           East          !
            \            !
             \           !
              \          !
               \         !
                \        !
                 \       !
                  \      !
                   \     !
                    \    !
                     \   !
                      \  !
North                  \ !
------------------------\!

                         The Tumble Axes

    Now twist your wrist and turn around. Naturally your
index finger (the yellow, East, tumble axis) can be pointed in
any direction. You can tilt it up or down, or swing it left or
right. Your index finger is said to have two degrees of
freedom, so far as pointing is concerned.

                                                                        10-6

    If you decide to point the East tumble axis (yellow) in a
particular direction -- towards a lamp, for example -- you will
suddenly find that the thumb and middle finger (purple and
white, the Up and North axes) can only be rotated around
the East axis, so long as you hold them at right angles.
These axes are reduced to one degree of freedom.

    Once you decide on an angle for one of the two
remaining axes, say North (white), then the last axis (Up,
purple, your thumb) is also fixed, having no degree of
freedom at all.

    The paint on your hand should be dry enough now that
we can go back to Sculpt Animate, where the Tumble Axes
for one vertex of your path have been waiting patiently. We
will assume that they are still in their original orientation.

    While the MODIFY INDICATED TUMBLE requester is
present, you can use the rotate gadgets in each Tri-View
window to twist these tumble axes. For instance, click the
counterclockwise rotate gadget in the North window a few
times, then click the same gadget in the Down window
several times. The yellow axis will be tilted up a bit, then
rotated towards the North. The white axis will still be level.

    In addition to rotating, you will notice that each axis line
has become visible in the one window where it couldn't be
seen before. As they are rotated, the axes will grow and
shrink in various windows according to their orientation.
This provides additional visual feedback.

    Yet another change will occur when you first rotate the
Tumble Axes for a particular vertex. This change takes place
in the MODIFY TUMBLE requester itself. The toggle
gadget titled 'Method:', which was previously marked
INTERPOLATED, will change to SPECIFIED. This means
that the tumble you have set for this vertex will be used.
Otherwise, Sculpt Animate will try to guess (interpolate) the
correct tumble by picking an orientation between the two
adjacent SPECIFIED tumbles. You may click the toggle
gadget back to INTERPOLATED if you change your mind.

                                                                        10-7

    To visualize the effect of the change we just made to the
Tumble Axes, let us abandon our poor man in the desert and
take up the case of a search plane trying to find him. Let's
say the plane has been built facing East, with the wings
level.

    If this plane were to fly along the path we've been
working with, then when it reached this location on the path
its nose would be pointed up a bit and it would be pointed
somewhat North of East, with the wings still level. In other
words, it would be positioned just like the Tumble Axes for
this vertex.

                     \ Purple
                      \
                       \
       White            \
            -------------\--------------- Yellow

                Tumble Axis Relationship

    Of course, if you only set the Tumble Axes for this one
vertex, then the plane will probably not fly very naturally.
As we have seen, you don't need to set a tumble axis for
every vertex on the path, just for certain important locations,
but you almost certainly need to set more than one. For
instance, you will probably want to specify the tumble for
the first and last position on a path.

    Let's imagine that you have created a new "S" curve path
for the airplane. (This can be done with a two-know spline,
try it!) Typically, a plane will enter this type of maneuver
flying straight and level, then tilt its wings in the direction of
the first turn (called "banking"), level out again between

                                                                        10-8

turns, bank the other way into the second turn and finally
level out again.

    Likely places for specifying the tumble are the first and
last vertices, the midpoint between curves, and the steepest
portion of the bank in the middle of each curve.

    The first, last, and middle tumbles are easy, since you
only have to rotate around one axis. Just indicate each of
these vertices and call MODIFY INDICATED TUMBLE,
then rotate the axes for that vertex in the Down window until
the yellow (East) axis is pointing along the path.

    Setting the tumble in the middle of the curve is a little
harder. It's a good example of a typical tumble axis
problem. You want the yellow axis to point along the path
here, too, but you want the other two axes to be tilted
sideways, to lean the airplane into the curve. So far you've
been working in the Down window, but now you need to
move to one of the side views, North or West. Go to the
side view where the yellow axis looks shortest, and rotate
the axes in the desired direction. If the yellow axis looks the
same in both side views (the worst case), just pick one at
random.

    If the yellow axis was visible at all in the view you used,
you will notice something a little troublesome. The rotate
gadgets in a Tri-View window can only rotate in the
window's frame reference. Because of this, if the yellow
axis is visible, there's a good chance that it will tilt either up
or down when you rotate the other two axes. To correct this
drift, go to the other side view and straighten the yellow
axis. This may 'unwind' your initial tilt a bit, but by
switching back and forth a couple of times you will get the
right position. When you get the right amount of bank, you
may also have to correct the heading in the Down window.

    This is a general rule. If you want to rotate the Tumble
Axes around one axis, use the window where the axis is
least visible. If that axis drifts anyway, correct it in the other
two windows. By repeating this cycle a couple of times,
you can get the right orientation fairly easily.

                                                                        10-9

    There's a trick that you can try until you get used to this.
If you want to rotate to a certain position around one axis,
align that axis with the Tri-View so that it disappears in one
window. You can now set the rotation easily in that
window. Once this is done, it is fairly simple to point the
remaining axis in the correct direction. In the case of our
airplane, for instance, you would tilt it up or down in one of
the side views, then set its heading in the Down view. You
will still get some interplay, but it shouldn't be bad unless
the plane climbs or dives radically.

    Once you have set the tumble axes for some
representative locations, it is a good idea to check the
vertices in-between. The NEXT and PREVIOUS gadgets
on the MODIFY TUMBLE requester let you step forwards
and backwards along the path, examining the tumble axes to
see if they are being interpolated the way you expected. In
this way you can 'test fly' the path. If the axes seem to
stray, move to the vertex where they seem most out of line
and set it as you wish, then examine surrounding vertices to
make sure they fell into line, too.

    A useful gadget that hasn't been mentioned yet is
MATCH LAST. It will swing the Tumble Axes around to
be aligned with the last set of axes that you positioned with
the requester. If you are working your way along a path
with the intent of rotating the axes a specific amount for each
vertex, then you will find that the interpolation often
anticipates you, messing up the count. To ensure a good
count, click MATCH LAST before setting each vertex.

    MATCH LAST can also be used to copy Tumble Axes
from one vertex to another. This is good for matching the
start and end of a path for looping animations, or for
copying Tumble Axes from one path to another. First, call
MODIFY INDICATED TUMBLE for the 'source' vertex,
then click both rotate gadgets in any window, once each.
This does nothing, but makes the program remember that
location's tumble. Finally, go to the 'destination' vertex and
click MATCH LAST.

                                                                        10-10

    For more precise work, note that the rotate gadgets may
be used with the Amiga and ALT keys as usual. The normal
rotation is 5 degrees per click. When clicked with the left
Amiga or ALT key pressed, rotation is 1 and 0.1 degrees,
respectively. The right Amiga and ALT keys make rotation
45 and 180 degrees per click, respectively.

Motion hierarchies

    We have seen how to create a special 'path' object and
set its Tumble Axes, to make another object 'attached' to the
path appear in a specific location and posture in every frame
of an animation. So far, we have neglected to mention how
the object is attached to the path.

    We have also see that objects and parts of objects may
be organized in a scene's hierarchy, so that objects may be
'attached' to one another with the lower level objects
'following' the higher level ones. We have hinted that
motion can be placed in the hierarchy somehow.

    By now, you've probably guessed how -- just put a path
in the hierarchy! Any object that is named as a path's
offspring will follow that path.

    There is a special command for naming paths: EDIT
NAME INDICATED PATH. Before calling it, indicate a
vertex on the path you want to name. Except for the title, the
requester that pops up is identical to NAME SELECTED
VERTICES, with gadgets for traversing the hierarchy and
entering a new name. When you click on the OK gadget, the
path will be names and place in the hierarchy.

    If a name in the hierarchy names a path, then when it is
in the 'current' slot the label 'path' will be shown with an
arrow pointing to the name.

    A path differs slightly from other objects in that only the
one path can be given a particular name on any given level.
If any other vertices already have the exact same name, they
will be 'unnamed' when the path is named.

                                                                        10-11

    On the other hand, if you give some vertices a path's
name, then the path will just be demoted to 'vertices' in the
hierarchy.

    Any number of named objects can be attached to a path,
using EDIT NAME SELECTED VERTICES to name them
as offspring of the path. All the offspring will move as a
unit. Consider this example:

                                        !---------- fuselage
                                        !
                                        !
 S_path ---------!---- airplane --------!----- wings
                 !                      !
                 !                      !
                 !--- pilot             !---- etc...

    The airplane, which is composed of a fuselage, wings,
etc., is attached to the object names 'S_path'. If this object
is a path, then the airplane will follow it. The object named
'pilot' will also follow along the path, moving as though it
were a part of the airplane.

    This shows that you can group objects under a single
name and attach that name to a path, or just attach all the
parts directly to the path. It's just a matter of convenience.
The former scheme is often easier, but either way there are
some important considerations about where parts will appear
relative to each other and to the path. The next section
explores this.

    We have been describing paths as a special sort of
object. Since objects can be attached to paths, can't paths be
attached to paths? Yes! The 'lower' path and its object will
simply follow the 'upper' path, like a flea walking on a
dog's back. This is called 'hierarchical motion', and it
allows very complex motions to be described easily.

    As an example, let's imagine a simplified orbital model
of the Earth/Moon/Sun system:

                                                                        10-12

 earthpath -------!------ earth
                  !
                  !--- moonpath ------- moon

    The name 'earthpath' can be given to a 364 vertex
circular path around the Sun. This path's name goes in the
top level of the hierarchy. Two objects are attached to
'earthpath': one is the earth object itself, the other is
'moonpath', a 28 vertex circular path around the earth. The
moon is attached to 'moonpath' (i.e., its offspring).

    Notice that the number of days per year and month have
been 'fudged'. This allows a smoothly looping 364 frame
animation (hard disk recommended!). More accuracy would
require much denser paths, and a 119802 frame loop!

    You might wonder why the sun isn't in the hierarchy. It
doesn't really have to be, since it doesn't move. Of course,
it could be named in the top level for editing purposes, if you
like.

    A better question might be how to get the two paths to be
centered around the Sun and Earth objects correctly, and
how to get the planets to follow their paths accurately. This
is not a matter of placement in the Tri-View, as we'll see
in the next section.

    If you're curious, this model could be done fairly close
to scale in Sculpt Animate, but it would be snug, and the
scales are so large it would be hard to make a very exciting
animation with it. Chapter 13 will show you how to use
coordinates to scale things. Using two decimal places in the
coordinates window, the Moon could have a radius of 1.00
units. The Earth's radius would then be 3.67, the Sun's
400.36. Moonpath's radius would be 221.14, and
earthpath's would be 86043.84. The model isn't perfectly
accurate, but it far exceeds the resolution of the Amiga's
screen.

                                                                        10-13

    By the way, these dimensional scales were derived from
the CRC Handbook of Chemistry and Physics, Robert C.
Weast, ed. (CRC Press, 1975), pp. F171+.

Local Origins

    So far, we have taken it for granted that when an object
is attached to a path, it moves 'along' the path, matching the
location of each path vertex in turn. But what does that
mean exactly?

    As our man runs in the desert, we might expect him to
run 'on' his path, so the soles of his feet match each path
vertex in turn. If the airplane is moving along the path, we
might expect something different.

    The point is, Sculpt Animate has no way to guess what
we expect, so we have to specify a certain point, relative to
any object, that will coincide with the 'active' vertex of the
object's path in any given frame.

    This point is called the object's local origin. It is
analogous to the guide pin on an old-fashioned slot car.
While the car might swing wildly about rounding curves, the
guide pin always follows the slot precisely (until it falls out).
The guide pin, like a local origin, serves a dual purpose. It
holds the car 'object' to its 'path', and it acts as a pivot for
the car's 'tumble'.

    When an object is created, its local origin matches the
center of the Sculpt universe, the 'absolute origin'. When
you run Sculpt Animate, this point will be in the center of the
Tri-View.

    Because of this, if you simply run the program and begin
building an object to animate, the object's local origin will
probably wind up somewhere near the object's middle. This
may do perfectly well for simple animations.

    When you begin to animate multiple objects, or objects
that need to tumble or pivot in a particular fashion, then you

                                                                        10-14

will need to remember to set a local origin for each animated object.

    To do this, first move the cursor to the place, relative to
the object, where you want its local origin to be. Next,
execute the menu command EDIT MODIFY LOCAL
ORIGIN. A familiar looking hierarchy requester will pop
up. In this requester, find the name of the object in question
and move it into the current name slot. Finally, click on the
SET gadget. The local origin will be set to coincide with the
cursor position. If you decide not to set a local origin, click
CANCEL.

    If, for any reason, your object's motion is not what you
expected, be sure to double-check its local origin. You can
do this by making its name current in the MODIFY LOCAL
ORIGIN requester and clicking SHOW.

    A local origin that was placed with SET will stay where
it is in the Tri-View, no matter how you move or modify the
associated object's vertices. This lets you fine tune and edit
an object even after its local origin is set.

    If you actually move an object, however, you may want
the object's local origin to move along with it. If you think
an object will be moved around after you set its local origin
(for instance, if you will be loading it into several different
scenes), then you can lock the local origin to a particular
vertex by indicating the vertex, then using the LOCK gadget
instead of SET. Whenever that vertex is moved in the Tri-
View, any local origin locked to it will follow.

    Usually, the vertex you LOCK to will be one of the local
origin's named vertices, but it doesn't have to be. This is
especially true of paths used in hierarchical motion. If you
were to LOCK a path's local origin to one of its own
vertices, it might not follow the parent path as you wish, but
you cannot give any other vertex the path's name. In this
case, the path's local origin would probably be locked to a
vertex of some object on the same level as the path.

                                                                        10-15

    Remember that you only need to set the local origin for
objects that move, and that the local origin is part of the
object, not of the path it follows. A path only needs a local
origin if it follows another path.

    For instance, take the orbital example of the last section.
'Earthpath' is highest in the hierarchy, and it does not move
in the universe. It does not need a local origin. 'Moonpath',
as well as the 'Earth' and 'Moon' objects, all move, so they
all need local origins.

    In the orbital example, it would be simplest to select each
of the objects in turn, call SNAP CURSOR TO CENTER,
and SET the object's local origin.

    Each of these objects is either circular of spherical, so
it makes sense for their centers to track the paths. This is
because a spheres 'center of gravity' tends to be at its
center. Objects in 'free fall' will always tumble about their
center of gravity.

    If an object is irregular, the command SNAP CURSOR
TO CENTROID may place the cursor near where the center
of gravity would be in real life. This depends on
the assumption that the vertices of the object are distributed the
same as the real object's mass would be, which is often not correct.

    Most people can learn to guess where an object's center
of gravity should be. If you can pick the object up, just feel
for its center of balance. In some cases, there is a rule of
thumb to determine the center of gravity of an object. For
example, on an airplane, the center of gravity usually lies
about one third of the way from the leading edge to the
trailing edge of the wing, except in unorthodox designs, like
canards.

    If the object is not in free fall, you might not want to
place the local origin at the center of gravity. A robot arm,
for instance, is often mounted to the floor. It would almost
certainly have its local origin at its shoulder bearing. For
another example, recall the slot car analogy. The slot car's

                                                                        10-16

guide pin is usually at the car's front end, well ahead of the
center of gravity. This is why slot cars often 'fishtail' as
they go through turns.

    For realistic motion, you should always try to find a real
life counterpart to the object you are modeling, and think of
it in terms of its 'path', 'local origin', and 'tumble'. By
examining reality, you can find the most effective way to
devise the animated motions you want. If realism is not
important, you can do just about anything you please!

    By now you will have realized that what you see in the
Tri-View as a static scene could represent a complicated
animation. The next chapter will explain how to get from
one to the other.

                                                                        10-17

                                CHAPTER 11

                           CREATING AN ANIMATION

    In the preceding chapter we saw how to define a motion
path in Sculpt Animate, but a motion path does not make an
animation by itself.

    For Sculpt Animate to construct an animation, it must go
through an automated sequence of steps, beginning with one
or more scenes which you create to describe the animation's
movement, and ending, in most cases, with a compressed
sequence of images that may be loaded into RAM and played
back as an animation.

    This chapter introduces a facility called a 'Take'. The
Take is a control panel which lets you make choices about
how the animation will be built.

    This chapter will also explain how a few scenes, or only
one, can be used by the Take to create the many images that
an animation needs. At last you will be able to make your
three dimensional objects move.

The Take

    In the motion picture industry, a 'take' is a scene or
portion of a scene that is photographed without interruption.
Clearly a lot of organizational effort is required for a
successful take.

    In the world of Sculpt Animate, the Take is a special file
which contains information needed to coordinate and control
the construction of an animated sequence. For instance, it
contains information about where each file associated with
the Take is to be stored. It also stores data relating to the
animation's imaging mode, screen size, etc., so that all of
the scene's frames are rendered consistently.

                                                                        11-1

    A number of other data are also kept in the take. Many
of the Take's controls may be set directly by you. Other
coordinating actions are performed by the Take automatically
as you proceed. These actions and settings will all be
explained in this chapter and the next.

    Before you begin working on an animation, you must
first specify the name of the Take. This name will be used to
prefix all of the files that are created in association with this
Take, so that different Takes cannot be confused.

!==========================================================!
!                     MODIFY TAKE                          !
!                                                          !
!                   Take mode: GLOBAL                      !
!                                                          !
! Number of frames:   10         RAM animation:  YES       !
!                                                          !
! Preview size:   FULL           Save images:  YES         !
!                                                          !
! Motion blur:   NO             Loop mode:  LOOP           !
!                                                          !
!              Animation drawer !----------------------!   !
!                               !----------------------!   !
!              Foreground:      !----------------------!   !
!                               !----------------------!   !
!              Background:      !----------------------!   !
!                                                          !
! SAVE GLOBAL SCENE  LOAD GLOBAL SCENE  DELETE ALL IMAGES  !
!                                                          !
!    PREVIEW            RENDER ALL             OK          !
!==========================================================!

               Modify Take, GLOBAL mode

    To set the Take's name, execute the command PROJECT
LOAD TAKE. The familiar file requester will pop up. If
you are continuing to work with a previously created Take,
then select it in the normal way, from the list of files that is
displayed, otherwise just type the new name into the
appropriate slot. Click the OK gadget to continue with the
new Take. If you change your mind about loading a new
Take, click CANCEL to exit without doing anything.

    You will find that you can still use Sculpt Animate just as
before. You can load, edit, and save scenes as usual, and
create and save images. As far as the normal use of the
program is concerned, there is no difference.

                                                                        11-2

    By naming the take, however, you have activated an
extremely powerful command: EDIT MODIFY TAKE,
which had previously been ghosted. Execute this command
and look at the requester that pops up. The MODIFY TAKE
requester is the control panel from making animations.

    When the MODIFY TAKE requester comes up for
the first time, it is in GLOBAL mode. At the top center of
the requester, there is a toggle gadget which switches the
requester between GLOBAL and its other mode, FRAME.

!=======================================================!
!                     MODIFY TAKE                       !
!                                                       !
!             Take mode:  FRAME                         !
!                                                       !
!             Current frame:    1                       !
!                                                       !
! Key frame:     NO              Duration:    (2)       !
!                                                       !
!            Image drawer: !-------------------------!  !
!                          !-------------------------!  !
!            Scene drawer: !-------------------------!  !
!                          !-------------------------!  !
!                                   10                  !
!                !=!=!=!=!=!=!=!=!=!=!                  !
!                ! ! ! ! ! ! ! ! ! ! !                  !
!                !=!=!=!=!=!=!=!=!=!=!                  !
!                /\                                     !
!  SAVE KEY FRAME SCENE          LOAD KEy FRAME SCENE   !
!                                                       !
!   RENDER FRAME      DELETE CURRENT IMAGE     OK       !
!=======================================================!

                   Modify Take, FRAME mode

    These two modes look radically different, because they
permit you to deal with the animation in two entirely
different ways. The GLOBAL mode contains settings and
commands for the entire animation, while FRAME mode
provides controls that let you deal with each frame of the
animation individually, on a frame by frame basis.

    To get a better grip on this distinction, examine each
mode of the requester. First, set the mode toggle gadget
back to the GLOBAL mode.

    It should not be hard to imagine that each control that is
visible in this mode has some function relating to the whole
animation. For instance, the box marked 'Number of

                                                                        11-3

frames' is obviously where you type in how many images
you want the program to create for your animation.

    Choosing the best number of frames can be a
complicated matter, involving the desired playing time,
display duration of each frame, memory considerations, etc.
For the sake of this discussion, type in the number 10.

    If you click the GLOBAL/FRAME toggle gadget again,
you can take a look at the requester's FRAME mode. In this
mode, everything you do affects individual frames of the
animation.

    You should see a row of ten boxes stretched across the
lower middle portion of the requester, looking suspiciously
like a strip of photographic film. This is the film strip
gadget. Each of these boxes represents a frame of the
animation. By clicking in a box, you make that frame the
'current frame'. This will be shown by the number in the
'current frame' slot, and by a small arrow beneath the
filmstrip.

    Another control in this mode is the 'duration' setting.
This is the display duration that we mentioned a moment
ago. The number in the box is how long, in 'jiffies', the
current frame's image will be displayed during playback.
One 'jiffy' is 1/60th of a second. Longer frame durations
make the animation seem slower. We will learn more of this
later in this chapter and the next.

    Before we continue, notice that you haven't seen any
command to save the Take. All the data associated with the
take is saved automatically whenever you click OK to get out
of the MODIFY TAKE requester, and also when you start an
animation render.

Two kinds of animation

    Just as there are two different modes to the Take,
GLOBAL and FRAME, there are two different ways you

                                                                        11-4

can create motion in Sculpt Animate, global animation and
key frame animation.

    Global animation is specified with a single scene, called
a 'global scene'. This scene contains motion paths and other
objects that have their effect globally, affecting every frame
of the animation. The global scene is also the best place to
put objects that don't move at all, since this ensures that they
will be present in every frame.

    Key frame animation is specified by two or more scenes.
A pair of key frames can contain objects that change position
and shape from one key frame to the next. Key frames do
not make any use of motion paths, and they only affect a
particular group of frames.

    As you might expect, creating global animations
demands extensive use of the Take's GLOBAL mode, and
key frame animations similarly are tied to the FRAME mode.
There is nothing sacred about this linkage, however. Both
the GLOBAL and FRAME modes provide tools that can be
used for any animation.

    Indeed, a particular Take may have motion and objects
that are defined in the global scene, and others that are
defined in key frame scenes. In creating the animation's
images, these two separate forms of animation are essentially
'played back' together.

    When the global and key frame animation methods are
used together this way, one or the other may take precedence
in determining certain placements and values. In general,
any key frame scene in its World illumination and sky settings,
as well as observer lens and tilt. The global scene's
Location and Target placements can be forced to take
precedence by entering their names in the global scene's
hierarchy. This is explained more fully in the next chapter.

                                                                        11-5

Global Animation

    You already have seen how to create scenes that contain
objects which are attached to paths in a motion hierarchy. In
essence, this is all there is to global animation, but in practice
there is a bit more that you need to know.

    In the Take requester, the two items that are essential to
global animation are the buttons marked SAVE GLOBAL
SCENE and LOAD GLOBAL SCENE, in the GLOBAL
mode.

    As you build a global animation, you piece together your
objects and paths in a single scene. This scene may be saved
and loaded just like any other, or pieces together from a
number of other scenes. It is very much like building an
animated machine of some sort.

    You cannot make your scene's 'machine' run, however,
until you load a Take and use SAVE GLOBAL SCENE in
the MODIFY TAKE requester to save it. This tells Sculpt
Animate to save the scene with a special file name associated
with the Take. File names are discussed in the next chapter.

    If you want to load in a previously saved global scene to
work with, use the GLOBAL mode button marked LOAD
GLOBAL SCENE, then click OK to get out of the Take
requester. This command will clear the Tri-View
automatically, so you don't need to execute an ERASE ALL
first.

An example global animation

    Enough explanation. It's time for you to make an
animation. We have already mentioned orbital paths on
something of a grand scale. For this animation, we will do
something much simpler -- make a cube fly around a circular
path.

                                                                        11-6

    To start, clear the Tri-View with EDIT ERASE ALL.
Execute PROJECT LOAD TAKE and enter a new name for
the Take. Any name will do, try 'global'.

    Now select the Down window and add a circle with 36
vertices. Select one vertex and indicate an adjacent vertex
with the cursor. now execute the command EDIT DO
MAKE PATH. This will be our 'orbital' path.

    Next, make a cube with the command EDIT ADD
CUBE. Make sure you have deselected the vertex on the
path and then select the cube. Call EDIT DO EXPAND and
shrink the cube to a size that is fairly small compared with
the circle.

    People will usually want to grab the cube and place it
'on' the path somehow, but you don't need to worry about
where the cube is placed. In the animation, it will
automatically be shown on the path we attach it to.

    We do need to set the cube's local origin, though. We'll
do this in a moment, so leave the cube selected and move the
cursor to its center with the command EDIT SNAP
CURSOR TO CENTER.

    Now we must set up a hierarchy. First, execute the
command EDIT NAME SELECTED VERTICES. Enter the
new name 'orbit', press return, and click on the
OFFSPRING box. Now enter the name 'cube' and press return.

    We have built a pretty simple hierarchy. The parent is
called 'orbit', but nothing has that name yet, it is just holding
a place in the hierarchy. 'orbit' has only one child, called
'cube'. Now click on the OK button to give that name to
each vertex of the cube.

    We will want the center of the cube to travel around the
circle, so we must set a local origin for the cube. The cursor
should still point to the center of the cube, so execute the
command EDIT MODIFY LOCAL ORIGIN and click on the
SET button. Leave the requester by clicking OK.

                                                                        11-7

    Next we must name the path. Move the cursor to
indicate one of the vertices on the circle and execute the
command EDIT NAME INDICATED PATH. 'Cube'
should be in the current slot where we left it. Click on the
Parentage box, so that 'orbit' becomes the current name,
then click on OK to leave the requester, giving the name
'orbit' to the circular path.

    Our motion hierarchy is now complete, the cube is
attached to the circular path. If you'd like, you can double
check this by calling any hierarchy command, and seeing
that 'orbit' names a path and 'cube' names vertices. Be
careful, though. When you are just looking at the hierarchy
remember to leave the requester by clicking CANCEL, or
you might do something you didn't intend to.

    Before rendering any animation, you must see that the
observer's location and target are placed appropriately.
Position the cursor above the place of the orbit, at a distance
of two or three times the size of the circle, then call
OBSERVER LOCATION. Next position the cursor in the
middle of the circle and call OBSERVER TARGET.

    We have now specified the global scene completely, and
we need to save it. While it is fine to save your interim work
using SAVE SCENE, the finished global scene must be
saved through the MODIFY TAKE requester.

    You have already given the take a name, so call up the
EDIT MODIFY TAKE requester and click on SAVE
GLOBAL SCENE. With the scene safely on disk, you can
set other take controls.

    Your final task is to set the number of frames. The path
has 36 vertices, so click on the 'Number of frames' box,
delete the previous number, type 36, and hit return. When
you click OK, the take file will automatically be saved.

    Congratulations! You have just prepared your first
animation, now let us see how you can watch it move.

                                                                        11-8

    Later in this chapter, we'll see how to render an
animation in full color, and compress the images for
playback from RAM. This process can be time consuming,
especially for large animations. In this particular case it
would be unrewarding as well, since we've neglected to put
a lamp in the scene.

    Right now, however, all we need to see is the motion of
the scene, and we aren't particularly interested in keeping the
results for posterity. For this purpose, Sculpt Animate
provides quick preview facility. This facility uses WIRE
FRAME mode in low resolution, so it can assemble the
animation in a minimum of time and memory.

    To start the preview, execute the EDIT MODIFY TAKE
command and make sure that the Take mode is set to
GLOBAL. Then click the PREVIEW gadget. Each frame of
the animation will be displayed as it is calculated. When all
the frames are done, the entire animation will be played
repeatedly.

    The initial speed (frame rate) of the playback will depend
on the duration that you have set for each frame of the
animation. In our example, we haven't changed the default
setting of 2 jiffies per frame, this means each image will be
shown on the screen for 1/30th of a second (1/25th of a
second on PAL Amigas).

                                                                        11-9

    While the preview is being played, you can press the
keyboard's top-row digit keys 0 through 9 to modify the
speed as follows:

    Key                Playback Speed

    0                normal rate
    2                2 jiffies per frame
    3                4 jiffies per frame
    4                8 jiffies per frame
        5                              16 jiffies per frame
        6                              30 jiffies per frame
        7                              60 jiffies per frame
        8                              120 jiffies per frame
        9                              240 jiffies per frame

    Pressing the spacebar will momentarily halt the
playback, pressing again resumes it.

    When you want to stop the preview entirely, press the
right mouse button or the ESC key. The preview screen will
be closed, and you will be asked whether you want to
unload the preview.

    If you think you will want to view the preview again
later in the session, you can answer NO to this question.
This causes the preview to be kept in memory. It can be
replayed from the Tri-View by executing the command
PROJECT SHOW PREVIEW.

    While the preview data is retained in memory, you will
have less memory for other things. You can free up this
memory at any time by executing the command PROJECT
UNLOAD PREVIEW.

    If your animation is very long, the preview display may
fail because of insufficient memory. In that case you can
return to the MODIFY TAKE requester, select GLOBAL
mode, change the 'preview size' gadget from FULL to
HALF, and try the preview again. Because the image

                                                                        11-10

generated has one fourth the area, the preview will only take
about one fourth the memory.

    Never hesitate to use the preview facility, it is much
faster than generating a full animation, and it will often show
you ways to improve your object motion and placement, as
well as your observer's position. The time you save will be
well worth this extra step.

Looking at individual frames

    When you are working with a global scene, objects and
paths will be placed however they were constructed. Objects
that are to follow paths in the animation might be placed in
an entirely different part of the scene as you construct it. In
the global scene this is perfectly all right, since an animated
object will move to the active vertex of its path anyway.

    As Sculpt Animate generates the images of the
animation, it will resolve the relationships between objects
and paths for every frame, creating a sort of 'working
version' of the original scene.

    If you want to see what this 'working version' of the
scene looks like in a particular frame, call the MODIFY
TAKE requester and click to the FRAME mode. Select any
frame of interest, click LOAD KEY FRAME SCENE. This
command automatically clears the Tri-View, so you don't
need to execute an ERASE ALL first. Now lick OK to get
back to the Tri-View.

    What you will see is the scene that Sculpt Animate will
use to create this frame's image. You can now move and
resize the Tri-View to examine various parts of the scene.
This allows you to make sure that the animation is
proceeding precisely as you expected.

    When you are looking at an individual frame's working
scene, you will find that some Tri-View commands will not
work as you may expect. For instance, none of the selection
or editing functions will work on the global scene's objects.

                                                                        11-11

The next section will explain that you are actually in a mode
which allows you to edit key frame objects while seeing how
they relate to global objects. You just don't have any key
frame objects yet.

    If you want to render an image of a frame's working
scene, select that frame in the FRAME mode of MODIFY
TAKE and then click RENDER FRAME. The image will be
rendered in the size and imaging mode that currently applies
for the take. This will what was set for the last global or key
frame scene that was saved before the last DELETE ALL
IMAGES command. The full effect of these commands will
be explained later.

    If you want RENDER FRAME to match the preview
images, set the imaging mode to LO-RES, NO-
INTERLACE, WIRE FRAME.

Key frame animation

    We mentioned in Chapter 1 that there are two ways of
animating objects: global animation and key frame
animation. We have already seen global animation in action.
It depends on a single scene, the GLOBAL scene, which
describes objects and motion that are to exist throughout the
animation. It works like a machine, in which groups of
vertices run about on tracks.

    Key frame animation works on a much different,
somewhat simpler principle. The idea is this: take two
scenes that are identical, then change the position of some
vertices in one of the scenes. The two scenes now describe
a motion for those vertices.

    If this kind of animation is to work, then the scenes that
describe the motion must be linked to particular frames.
These frames are called 'key' frames. The scenes we save
for these frames are called key frame scenes.

    You have to tell Sculpt Animate which frames will be
key frames. This is done in the FRAME mode of the

                                                                        11-12

MODIFY TAKE requester. You simply select the frame
you want, then click the 'Key Frame' toggle gadget from
NO to YES.

    Once you have tagged the frame as a key frame, you can
click SAVE KEY FRAME SCENE. This saves whatever
scene is in the Tri-View as the current frame's scene.

    A key frame scene is created much like any other, by
editing in the Tri-View. The contents of these scenes must
be coordinated in a particular fashion, which relates to how
Sculpt Animate uses the key frame scenes.

    We have said that certain frames will be key frames, so it
follows that not every frame needs to be a key frame. The
position of key frame objects in non-key frames is derived
by comparing the two adjacent key frames, one before and
one after the current frame. Specific rules are applied which
will be explained later.

    Key frame motion is resolved when Sculpt Animate
constructs a 'working scene' for the frame that is being
rendered. This is the same working scene that we mentioned
with respect to global animation. If there is a global scene,
it will also be resolved and contribute to the frame's image.

    Even if all of the motion you design is done in key
frames, it is likely that your animation has some components
that do not change in any of the frames. These may be
stationary objects like furniture or trees. Objects like this
may be placed in the global scene. By keeping these objects
in the global scene, you avoid having to worry about them in
the key frame scenes, and you reduce the amount of storage
required for the Take.

    As we saw before, you can use the MODIFY TAKE
gadget LOAD KEY FRAME SCENE to load in a 'working
scene' representing the state of the animation in the current
frame. This command automatically clears the Tri-View, so
you don't need to execute an ERASE ALL first. Click OK
to get back to the Tri-View.

                                                                        11-13

    If there are objects in the global scene, they will now be
visible in the Tri-View, but they may not be edited or
changed. If the frame is not a key frame, objects present in
the adjacent key frames will also be visible, but not alterable.

    If, however, you have selected a key frame, that frame's
scene will be loaded in. Global objects will still be visible so
that you can use them as a reference for placing key frame
objects. When you have finished editing, call MODIFY
TAKE again, and click SAVE KEY FRAME SCENE. Of
course, only the key frame objects will be saved.

    We will discuss additional key frame editing techniques
later in this chapter.

In-betweening

    We have said that Sculpt Animate 'resolves' the
difference between two adjacent key frames, creating
motion. This deserves more explanation.

    Suppose that you specify frame ten and frame twenty to
be key frames, with no other frames in that interval.
Each key frame has its own scene. When Sculpt Animate
comes to render an image for a frame that is not a key frame,
frame thirteen, for example, it interpolates between the key
frames that lie to either side.

    Suppose that each key frame contained only a single
vertex, then the interpolation process, or in-betweening,
would assume that the vertex moved smoothly from its
position in frame ten to its position in frame twenty. In
frame thirteen, the vertex is placed 30% of the way along the
path.

    So far so good. Now let us complicate the scenes and
place two vertices in each key frame. The in-betweening
process can be carried out as before, provided that we know
which vertex in frame ten corresponds to which vertex in
frame twenty. It is up to you to supply the clues that let
Sculpt Animate resolve the dilemma. Suppose the two

                                                                        11-14

vertices in frame ten are called A and B, and the two vertices
in frame twenty are called C and D, then which of the
following do you want?

A            C         A ---------------------- C
 \          /
  \        /
   \      /      or
    \    /
     \  /              B ---------------------- D
      \/
      /\
     /  \
    /    \
   /      \
  /        \
 /          \
B            D

frame 10     frame 20    frame 10            frame 20

    The second might see preferable, in that the paths do
not cross, but in three dimensions, the majority of lines do
not intersect. If we had more than two vertices, it would
become still harder to decide which vertex in one frame
corresponded to a vertex in the other frame.

    You could be required to assign a unique name for each
vertex, but that would be a painful chore if your scene had a
thousand or more vertices. Fortunately, this is not
necessary.

    It turns out that the vertices and other parts of a scene are
stored in a particular order as they are created. This order
remains the same in the scene as long as nothing is added or
deleted. In particular, the order remains the same whenever
vertices are moved.

    In order for key frame animation to work, you need only
make sure that consecutive key frame scenes are modified
copies of the same scene.

    If this sounds complicated, it could not be easier in
practice. If there is to be a global scene, you can design it
first and save it with SAVE GLOBAL SCENE, this can be
helpful in editing key frames, as we mentioned.

    Now, suppose that our animation has one key frame
every five frames, so that the key frames are 1, 6, 11, 16,
etc. In the MODIFY TAKE requester, go through and mark
every fifth frame as a key frame. Now use LOAD KEY

                                                                        11-15

FRAME SCENE to load frame number one. There is no key
frame data yet, so only the global portion of the frame will
be visible in the Tri-View. Assemble the scene using any of
the regular Sculpt Animate tools, and save the scene with
SAVE KEY FRAME SCENE when you are finished.

    Scene number one has been saved now, but a copy of it
is still in the Tri-View. You can manipulate this scene, move
or rotate objects, apply the magnet tools, do anything that
you wish, but do not create or erase any vertices, edges or
faces.

    If you somehow alter the scene's structure, say by
accidentally adding a vertex, just use LOAD KEY FRAME
SCENE to load in the first frame again.

    When the scene is to your liking, go back to MODIFY
TAKE and change the frame number to six, then use SAVE
KEY FRAME SCENE to save the scene. Sculpt Animate
can not interpolate between frames one and six with no
danger of ambiguity, since each vertex, edge and face in key
frame one has its matched twin in frame six.

    You can apply this technique to bridge the gap between
any two key frames that are separated by a number of non-
key frames. There is a quick way to check a pair of key
frames to make sure their structures match. Just select a
frame between them and call LOAD KEY FRAME SCENE.
If the structures don't match, an error message will
appear. Otherwise, the interpolated scene will be loaded as usual.

    By now you may think that all of a Take's key frame
scenes must have the same structure, the same number of
vertices, etc. Fortunately, this is not always the case. This
strict rule permits in-betweening, but if two adjacent frames
are both key frames, no in-betweening takes place. Two
key frames placed together may be as different as you like.

    Suppose that you have two animated rabbits, and you
want one of them to magically vanish after frame 20. Build
the scenes as usual for the key frames before frame number
20. Make sure that frame number 20 is a key frame, and

                                                                        11-16

save its scene. Now make frame number 21 a key frame
also. Erase one of the rabbits in this frame's scene and save
it, then continue to construct subsequent key frames,
ensuring that their structures match as needed.

X -------------- X          --------------

X -------------- X        X ------------- X

frame 15     frame 20   frame 21        frame 25

    The rule is simple, whenever you have a frame that is not
a key frame, the key frame before and the key frame after
must be derived from the same scene, with nothing added or
removed. Whenever additions or removals are required, you
must use two adjacent key frames to make the transition.

In-Betweening distortion

    The in-betweening process is very simple, involving
linear interpolation, but it can produce strange effects.
Consider the following case: two key frames, frames
number 12 and 18, with no key frames between them. A
triangle in frame 18 is identical to the corresponding triangle
in frame 12, except that it has been rotated to be a moderate
angle, say 90 degrees. The in-betweening process for frame
15 is shown below

          /\                               !\
         /  \          -----------         ! \
        /    \          \      /           !  \
       /      \          \    /            !   \
      /        \          \  /             !   /
     /----------\          \/              !  /
                                           ! /
                                           !/
         frame 12       frame 15         frame 18

                                                                        11-17

    You can see that at frame 15, the triangle generated by
the in-betweening process is much smaller than the two
identically shaped triangles in the key frames. The way to
minimize this distortion is to insert more key frames, and
ensure that objects do not change too much from one key
frame to the next.

An example key frame animation

    Let us remake our animation of the orbiting cube using
key frame animation. First clear the Tri-View with EDIT
ERASE ALL. If you have been working with a Take, you
will be asked if you wish to erase it. Answer OK to this --
nothing will be lost, the Take still exists safely on disk, you
are just erasing the copy that is held in memory.

    Next, add a cube to the Tri-View and click the Expand
Tri-View gadget until the cube is about one eighth of the size
of the Tri-View. Select all the vertices and position the
cursor just inside the Down window's bottom edge, in the
middle.

    This will be the animation's center of interest, so execute
the OBSERVER TARGET command, to place the target.

    We will be flying the cube around the target in a circular
path, so we must set the observer where it can see the action.
Expand the Tri-View again, this time until the distance from
the target to the cube is about one eighth of the Tri-View's
width, and place the cursor at the bottom of the Down
window. Go to the North window and move the cursor up
by about one third of the height of the Tri-View. Execute the
command OBSERVER LOCATION.

    Place the cursor on the target -- this will require moving it
in two windows.  Next click on the Center Tri-View gadget,
then click Shrink Tri-View until the cube is just about to
leave the Tri-View.

    When you 'zoom in' with Shrink Tri-View, the cursor
and target might seem to drift apart. This is because

                                                                        11-18

shrinking the Tri-View increases its resolution, making a
small error in placement seem larger. If this happens, just
move the cursor back to the target again.

    Now we are ready to set the cube in motion. Execute
PROJECT LOAD TAKE to name a new take (try
'key_frame'), then call up the MODIFY TAKE requester and
enter 36 as the number of frames in the global mode.
Remember that you need to click in the box, change the
number, and press the return key to enter the new value.

    Since our cube is to fly around a full circle of 36 frames,
it must move 10 degrees per frame. Let's make every fourth
frame a key frame. Click on the Take mode gadget so that it
becomes FRAME. Click on the film strip gadget for frame
number 1 and click on the Key frame box so that it changes
from NO to YES. A letter 'K' will appear in the first frame
of the film strip image to indicate that this is a key frame.
Now click on the fifth frame and again click on the Key
frame box. Repeat the process until frames 1, 5, 9, 13, 17,
21, 25, 29, 33 and 36 are all key frames.

    It doesn't take a mathematician to see that 36 is only the
third frame past 33, but there's a good reason for this
inconsistency. To see why, recall that in the global
animation we also used 36 frames. The circular path
naturally had a 10 degree arc between vertices. Of course,
one of these arcs was the one linking frame 36 and frame 1.
This arc had its effect when the animation looped, making a
smooth transition from one cycle to the next. Our key
frames don't specifically account for this last 10 degrees, but
if we just leave off 10 degrees 'short' at frame 36,
everything will work when the animation loops. Honest!

    Examples are for doing, so let's create the scenes. Click
on the first frame in the film strip gadget, then click on the
SAVE KEY FRAME SCENE button. This saves the scene
in the Tri-View as the first key frame. Now we must
construct the next key frame scene, which is frame 5. Click
on the OK gadget in order to leave the requester.

                                                                        11-19

    Back in the Tri-View, make sure that the cursor is lined
up over the target, and that the cube is visible near the top of
the down window. We need to rotate the cube around the
target in a clockwise direction by 40 degrees. You can either
click on the clockwise rotation gadget in the Down window
8 times, or click on it once with the right Amiga key held
down (for a 45 degree rotation) and then click the counter-
clockwise gadget in the Down window once (to back up by
five degrees).

    Return to the Modify Take requester with an EDIT
MODIFY TAKE command. Click on the image for frame
number 5 and press the button SAVE KEY FRAME SCENE.

    Repeat this process for each frame, rotating the cube
around the target and saving the key frame scene.
Remember we need to leave frame 36 short by 10 degrees,
so only rotate the cube 30 degrees (6 clicks) for this frame.

    Once you have saved all the key frames, all you need to
do to see your handiwork is toggle to the GLOBAL mode
and click PREVIEW.

Global vs. Key frame

    If you have followed through with this chapter's two
less-than-exciting animations, you may have noticed a
couple of differences. The circular motion in the global
animation looks smoother than that of the key frame
animation. This is because, due to in-betweening, the actual
path of the cube in the key frame was a nonogon, or nine
sided figure, while in the global animation it was a 36 sided
figure, which is much closer to a circle. Take care, when
using key frame animation, that the interval between key
frames is not too large, or motions may become
unacceptably jerky.

    The other difference is more obvious. In the key frame
animation, the cube can be rotated so as to keep the same
face towards the center of the orbit, like the moon does to the

                                                                        11-20

earth, while the cube in the global animation did not rotate at
all.

    To make the cube rotate in the global animation, you
must rotate the tumble axes. To see how, do an ERASE
ALL to clear out the key frame Take, then call PROJECT
LOAD TAKE. This time, find the name you gave the global
example then double-click that name in the list of files.

    Invoke the Modify Take requester and click on the
LOAD GLOBAL SCENE box. Now leave the requester and
point the cursor at the most easterly vertex on the circle and
execute the command EDIT MODIFY INDICATED
TUMBLE. Move the requester so that you can see the down
window. Click on the Method box, so that it changes from
INTERPOLATED to SPECIFIED.

    This will do for the first vertex. Now click the NEXT
button four times and move the tumble axes around the
orbit. Click the Method box to set the value to SPECIFIED.
Rotate the tumble axis by 40 degrees, and the white tumble
axis will move to become tangent to the circle again.

    Continue around the circle in this fashion, setting the
tumble axes appropriately for every fourth vertex. As you
proceed, of course, the interpolation mechanism will be
trying to help, so use the MATCH LAST gadget before
setting each vertex. This ensures that you rotate its axes
exactly 40 degrees. For most 'spinning' paths, a setting is
needed every 30-45 degrees for interpolation to be smooth.

    You can probably see that each of these types of
animation has its own strengths. Global animation is able to
describe smooth, flowing motions with complicated
tumbling, free of key frame distortion. On the other hand,
key framing allows things that global animation doesn't,
such as changing an object's shape or color, and its an easy
way to describe simple point-to-point motion.

    Most people will 'take' one method or the other at
first. This is fine, explore the one that makes the most sense
to you right now. The other will wait patiently until you've

                                                                        11-21

gained confidence. Eventually you will be able to pick the
one that best suits whatever object or motion you have in
mind.

RAM animation

    So far, all of the animations you have done were WIRE
FRAME previews. These two-color images are small
enough in memory that they can be stored directly in RAM
and 'page-flipped' to the screen for animation. We've seen
that Sculpt Animate can create much more beautiful images
than these, in full color and much higher resolution. The
more impressive images have a cost, though, in the amount
of data they contain.

    An image rendered in HI-RES, INTERLACE,
PAINTING, for instance, can take over 16 times the
memory that a preview image does. Typically, color images
occupy between 50,000 and 100,000 bytes. To show a
single second of animation, then, involves moving about 2
megabytes of data into the Amiga's 'chip' graphics RAM
every second. This data rate is more than the Amiga's
processor can handle, even if the whole animation could be
loaded into expansion memory and copied from there.

    Fortunately, in most cases, not all of the image data
needs to be moved. One frame in an animation is usually
very similar to its predecessor, so only the differences
between the frames need to be changed. This technique was
used to produce the Juggler demonstration in 1986, and has
since become known as 'delta' compression. (The Greek
letter delta is often used to symbolize change or
displacement.) The data describing the changes from one
frame to another is called 'delta data'.

    In delta compression, an animation is reduced to an
initial image plus a series of data chunks that can be used to
reproduce each subsequent image by altering the current one.
A standard file format, called the ANIM format, has been
suggested for animation files. Sculpt Animate employs
a variation of this format called J-type animation. At this

                                                                        11-22

writing, at least three other ANIM formats are in use. A
format converter for use with Sculpt Animate anim files is
pending.

    RAM animation is not without its drawbacks. Because
two consecutive images are compared on a pixel by pixel
basis, some animations may not be amenable to delta
compression. The problem occurs if a very large part of the
image changes from one frame to the next, as when large
objects pass very close to the camera.

    Even more extreme cases are when the observer's
location or target are moved, the observer lens's focal length
is changed, or lamps are moved. These are advanced
techniques that will be discussed in the next chapter. Each
of them virtually guarantees that nearly every pixel of the
image will change. Since some overhead is involved in
compression, this can lead to 'compressed' anim files that
are larger than the original image date.

    Too much motion will not only cause extremely large
anim files. It also slows animation playback, since it
increases the amount of data that must be moved by the
processor. In a typical application, if you do not achieve a
compression ratio of at least three-to-one between the image
size and the delta data, the animation is unlikely to replay at
the desirable rate of two jiffies per frame (25 or 30 frames
per second).

    The other obvious restriction for RAM animations is that
the amount of memory on your machine limits the total
duration of the animation. If each image is moderately
different from the next, you can expect to play about three
seconds of animation for each megabyte of available
memory. If only small portions of an image are changing,
the duration could be as long as 30 seconds per megabyte.

    The apparent length of an animation can be increased by
designing it in such a way that it repeats itself in a short
length of time. Such looping animations are obviously less
interesting than a full length feature film, nevertheless,
impressive animation demos have been made in this way.

                                                                        11-23

    You need not restrict yourself to a single object moving
in a circle. For example, you could produce a scene of a
column of troops marching along a twisting road. In the
time that it takes one figure to march the distance between
himself and the person in front of him, the scene can be
made to exactly repeat itself. An animation can also be
extended by carefully placing pauses in the action, in the
form of particular frames with long duration values.
Although RAM animation does not impose some severe
restrictions, there is no limit to the creativity that can be
applied to this new art form.

    RAM animations serve two purposes. As a stand alone
end product they may be acceptable for short animations, a
spinning logo for a commercial, for example. Alternatively,
short animation Takes may be assembled into longer
sequences by combining them on video tape using standard
videotape editing techniques. This probably represents the
most cost-effective approach to computer generated video
animations.

Making a RAM animation

    The button marked RENDER ALL in the GLOBAL
mode of the MODIFY TAKE requester starts the rendering.
The preparation required for this process is essentially
identical to that for a preview, but there are a few additional
items that need to be attended to.

    First, you obviously need to consider color, texture, and
lighting in preparing your animation. The examples created
so far didn't even have any lamps, you should place at least
one in the global scene. Everything you have learned about
creating good images applies here. Don't fail to try a few
test shots with the faster modes and sizes before committing
to the full render. Look for good color, lighting, and
composition. Remember, though, that the fancier textures
look pretty bad in SKETCH and PAINTING; take this into
account.

                                                                        11-24

    You will also need to remember to set the imaging mode
and size for your animation. These settings are taken
automatically from the last scene saved with either SAVE
KEY FRAME SCENE or SAVE GLOBAL SCENE.

    An animation may consist of dozens or even hundreds of
images, and take days to render. Because of this, be sure to
render a few test images here and there throughout the
animation, using the RENDER FRAME button in the
FRAME mode of MODIFY TAKE. This command will
render the frame's image in the current imaging mode, as
discussed before, and then save the data to disk.

    Finally, it is a good idea to click DELETE ALL IMAGES
before starting a full render. If you have used RENDER
FRAME in setting up you animation, then some undesirable
images may remain on disk. These will not be re-rendered.
Also, the color map and imaging mode may have been
'locked'. The meaning of this will be explained in the next
chapter, but for now just remember that DELETE ALL
IMAGES resets the Take and makes it ready to start a new
render.

    If you are sure that the color map and imaging mode are
OK then you can skip the DELETE ALL IMAGES. This
avoids having to render those images twice. If you want to
delete one image, but not all of them, use DELETE
CURRENT IMAGE in the FRAME mode.

    When you finally click RENDER ALL, a process will
begin that closely resembles the PREVIEW render, with a
few exceptions. We will look at this process as it would
occur normally, with the GLOBAL mode controls (except
number of frames) set to their defaults. We'll discuss
variations in the next chapter.

    First, Sculpt Animate will go through the animation
frame by frame, rendering all the images. These images will
be saved out to disk individually, by default in the same
directory that was specified in the LOAD TAKE requester.
Unless the animation is fairly small in size, you will need a

                                                                        11-25

hard disk to handle all this data en masse. Alternatives for
floppy disk users are discussed in the next chapter.

    Once all the images have been rendered, Sculpt Animate
will again proceed through the animation. This time it will
go through leapfrog fashion, finding the differences between
alternating pairs of images. It starts as you might expect
with frames 1 and 2, but then it goes to 1 & 3, 2 & 4, etc. The
images are compressed this way to facilitate 'double-
buffered' playback. Double buffering keeps two images in
memory for the best possible speed, one is updated while the
other is displayed.

    As each delta is found, it is written out to the animation
load file, or 'anim' file. This file will contain the complete
compressed animation, ready to be loaded and played back.
The anim file is also saved to the Take directory by default.
Consult the next chapter if this is not desired.

    The compression phase can be quite lengthy, since the
compression scheme was designed for greatest compression
and fastest playback speed, not shortest compression time.
You can use a much faster compression scheme by clicking
MODIFY TAKE's RAM animation gadget from YES to
ECONOMY, its second state. ECONOMY compression is
much faster in calculation, but generally creates larger anim
files that may not play as fast.

    When the animation render is finished, you can click OK
to get back to the Tri-View. If you have to interrupt the
render (by pressing CTRL-C), or if it is stopped for any
other reason, any images that have been saved will still be
present, and will not need to be re-rendered. When you
click RENDER ALL again, the render will pick up where it
left off. If the compression phase is interrupted, it will start
again at the beginning.

Playing a RAM animation

    Before an animation can be displayed, it must be loaded
into memory. This is done with the command PROJECT

                                                                        11-26

LOAD ANIMATION. A familiar looking file requester will
enable you to select which animation you wish to play.
Having loaded the animation, it can be displayed with the
command PROJECT SHOW ANIMATION. The animation
can be stopped by clicking with the right mouse button or by
pressing the ESC key. The speed can be changed in the same
way that the speed of a preview is changed.

    After stopping an animation, it remains in memory so
that it can be replayed without having to be reloaded. Use
the command PROJECT UNLOAD ANIMATION to make
the memory available for other purposes.

    One imaging mode, HI-RES INTERLACE (non HAM),
requires more chip memory for playback, in the larger image
sizes, than is available in the Amiga while Sculpt Animate is
running. If Sculpt Animate won't play an animation, this
may be why. The freely distributable Movie program,
included on one of your distribution disks, can play any
Sculpt Animate animation.

                                                                        11-27

                                CHAPTER 12

                      ADVANCED ANIMATION TECHNIQUES

    The last chapter walked you through the basics of
animating scenes with Sculpt Animate. The discussion has
focused on the simplest conditions, leaving many of the
available options in their 'default' state. This chapter
describes these additional options, which you can use as you
gain confidence in creating animations.

        Also in this chapter are sections which introduce some
advanced animation techniques.

Loop mode

    One of the options we have ignored is provided by the
MODIFY TAKE gadget marked 'Loop mode:'. This option only
applies to RAM animation and PREVIEW renders. For
other animation types the gadget will not be visible.

    The default setting for this gadget is LOOP. We have
already seen this mode in action. In it, the animation starts
over again after the last frame is displayed. We have also
seen that the last and first frames should usually not be
identical, otherwise the motion will seem to pause for an
extra frame when the animation loops. A five frame
animation would loop as 1, 2, 3, 4, 5, 1, 2, 3, etc. When
LOOP is in effect, RAM compression will not stop at the last
frames, since deltas must be calculated to carry the animation
through to frames 1 and 2.

    An alternative way of producing an animation is to have
it replay in the form of an oscillation. Set the loop mode
gadget to OSCILLATE before rendering the animation. A
five frame oscillating animation will play the frames in the
following order: 1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, etc.

                                                                        12-1

    If the loop mode gadget is set to NONE, then the
animation will simply play to the end and then stop.

Frame duration

    We have already mentioned frame duration, but it is
important enough that it deserves a fuller explanation.

    The 'duration' of a frame is the time, in jiffies, that that
frame's image will be displayed during playback. The
duration might actually be longer than what you set, since
some animations can be too complex to play back at full
speed.

    The definition of 'jiffy' can vary, depending on where
you live. In the United States and Japan the video standard
is NTSC, which displays each image as two interleaved
fields, at 60 fields per second, so an NTSC jiffy is 1/60th of
a second. In Europe, Australia, and elsewhere, the video
standard is PAL. A PAL video jiffy is 1/50th of a second.

    If the images are being sent to a single frame controller
(explained later in this chapter), then the set duration for each
frame will be passed to the driver. The frame controller
driver must decide how to interpret this value; for instance, a
video frame controller might record a field for every jiffy,
a film recorder might do otherwise. The driver's
documentation should explain how it uses this data.

    When you first call up the FRAME mode of the
MODIFY TAKE requester, you will see that the duration of
frame one is shown as zero. When a frame's duration is set
to zero, this has a special meaning. The duration actually
used will be the same as that used for the frame before; for
frame one, this duration is assumed to be two. Since the
durations for a take are all initialized to zero, the default
frame duration for the whole animation is two jiffies, or
1/30th of a second  in NTSC.

    If you click to subsequent frames, you will see that
the duration is shown as '(2)'. The parentheses show that this

                                                                        12-2

is a derived value. When you click back to frame one, its
duration is now shown this way, too.

    This odd behavior allows you to set the duration for a
large number of frames at once. If you click in the duration
box and delete the old value (be sure to delete parentheses,
too), then you can type in a new number. This number will
take effect for this frame, and all subsequent frames that
have not been set otherwise.

    One note of caution: If you want to set a unique duration
for a frame somewhere in the middle of the animation, you
will need to set the next frame's duration back to the default.
Otherwise the rest of the animation would take on the new
value.

    Frame duration is directly linked to both the apparent
smoothness and the playing time of the animation. In
NTSC, a 30 frame animation will last only one second at
two jiffies per frame.

    You will find that two jiffies is a very short time. Path
motion that is to be played at this rate will probably seem
overly fast unless the path used is somewhat densely
subdivided. This means more frames overall, and longer
rendering time for the animation.

    If the ultimate goal is a pleasant representation of the
motion, then the higher rate may be necessary. In this case,
it might be wise to stick to the PAINTING or SNAPSHOT
modes, and avoid PHOTO if rendering time is critical.
Indeed, if motion is the primary subject of the animation,
even WIRE FRAME can do very well at conveying this.

    If a positional representation is all that is desired, and
stunning imagery is to be the centerpiece of the work, you
can specify durations of four or more jiffies and still get the
point across. This drastically reduces the number of frames,
and hence rendering time, at the cost of some jerkiness in the
motion. With practice, you will learn how to weigh these
considerations according to your own taste.

                                                                        12-3

File name conventions

    If you use the Amiga's command line interface (CLI),
you will probably have noticed that Sculpt Animate creates
image files with names that end in '.image', and object and
scene files that end in '.scene'. This is how the program is
able to tell different types of files apart.

    You will not be surprised to learn that a Take file ends
in '.take'. The Take file is quite small, because it does not
actually contain any scenes or date, instead it accesses
separate scene and data files.

    When you name a Take, you are also indirectly naming
all of its scenes. If the name of the Take is 'xyz', its file
name is actually 'xyz.take'. The take's global scene file is
called 'xyz.g.scene' and the first key frame scene is
called 'xyz.scene' and the first key frame scene is called
'xyz.1.scene'. If frame 20 is a key frame, its scene would
be called 'xyz.20.scene'. When images are generated, they
have names that are similar. The name for the image for
frame number 20 is 'xyz.20.image'.

    This simple naming convention is carried out
automatically, so you don't have to worry about it. When
you are using the Amiga's CLI to maintain your directories,
however, it makes it easier to distinguish between the files of
various takes. The Amiga's LIST and DELETE commands
permit the use of patterns, for instance the command 'LIST p
xyz.#?' will list every file associated with the Take named
'xyz'.

    Note that Sculpt Animate does not save '.info' files for
the file it creates, so they will have no icons on the
Workbench screen. Sculpt Animate can easily create
hundreds of files on a single directory, so icons would
quickly become useless. The '.info' files themselves would
effectively double the number of files, drastically slowing
disk access for some operations.

    If you haven't done so already, you will find it valuable
to study your Amiga's CLI documentation before going very
far with Sculpt Animate. The definitive source for this

                                                                        12-4

information is The AmigaDOS Manual, from Bantam
Books, which is available through most bookstores where
computer books are sold. This book fully explains the
Amiga's file system and CLI. There are also several novice-
oriented AmigaDOS texts on the market.

Disk space

    In the course of generating an animation, you may find
yourself dealing with many megabytes of data, so a little
advance planning is wise. At times, you may need to
estimate how much disk space each image will take.

    Sculpt Animate's images are stored in a compressed
format, which can vary in size from image to image, so you
will need to check the size of an image from your particular
animation. To do this, use RENDER FRAME to generate a
test image before you click RENDER ALL. Try to pick the
'busiest' frame--an image with many transitions from one
color to another will generally use more disk space, and be a
'safer' indicator of what's needed.

    Once RENDER FRAME has saved the image, go back to the
Workbench screen and the Amiga's CLI window. Use the
CD command to change your current directory to the drawer
where the image is stored (the same drawer where you
opened your Take). Then use the AmigaDOS LIST
command to see how many bytes are in the test image.

    In the Amiga's operating system, disk storage is
measured in 'blocks' of 512 bytes. Typically, because of
system overhead, only 488 bytes will be usable per block.
A newly formatted Amiga floppy disk can hold 1751 blocks
of data (1758 if the 'noicons' option is used).

    To see how many blocks are used by your test image,
divide its number of bytes by 488, round up, and add 1. To
see how many images will fit on a floppy, divide the number
of blocks into 1751, round down, then subtract one to be
safe.

                                                                        12-5

    If the floppy is partially full, or you will be using a
directory on a hard disk or some other device, the CLI
"INFO" command will show how many free blocks remain
on each device in the system.

Organizing floppy disks

    So far, our discussion applies to using Sculpt Animate
on hard disk systems as well as floppies. While the hard
disk is preferable, by far, it is possible to render and
compress RAM animations using only floppy disks.

    The key to this endeavor is the old maxim: a place for
each thing, and each thing in its place. You will need to find
room for the Take and its associated scenes and images, as
well as a place for the final animation.

    Sculpt Animate makes use of 'overlays', segments of
code that are loaded in at various times, depending on what
is being done. This reduces the amount of memory required
to run the program, but it means that the program will need
to consult its own disk at times during a session. Sculpt
Animate also uses code libraries kept on the Workbench
disk. To reduce the amount of swapping required, you can
'boot' from your working copy of the Sculpt Animate disk
(insert it instead of Workbench).

    The Take and scenes will usually fit on the floppy disk
with Sculpt Animate, so they're no problem. If the scene
files need to be placed on separate disks, the procedure will
be much the same as for image files, which we will discuss
in detail.

    Image files definitely are a problem, since as few as five
might fill up a disk. A full disk error will bring the
rendering process to a grinding halt. The anim file is also a
problem, but we'll discuss that in a moment.

    To avoid running out of space while rendering, use the
last section's formulae to figure out how many of your
animation's images will fit on a disk. Before you start the

                                                                        12-6

animation, format (initialize) enough disks to hold all of the
frames' images. Name each of these disks with a short,
unique name, like 'images1-5', 'images6-11', etc.

    Now, how is Sculpt Animate to know which image goes
on which disk? You are able to specify a disk name
in the 'image drawer' gadget of MODIFY TAKE, in the FRAME
mode. Select each frame in turn, and type in a disk name for
every frame. Use the 'scene drawer' gadget if you need to
do this for key frame scenes.

    Do not type in 'DF0:', or any other device names, into
these drawer gadgets. This does not give Sculpt Animate
any way to ask for the correct disk. Use only the unique
volume names of one of the floppies you have formatted.
Remember, however, that a disk's volume name must be
entered into the gadget with a trailing colon, e.g.,
'images1-5:'.

    The image and scene drawer gadgets work similarly to
the duration gadget, in that any name you enter will be
carried over to any subsequent frames that don't have an
image drawer specified. This reduces the amount of typing
that has to be done. A derived name (one that is carried
over) will be shown in parentheses. Be sure that you erase
the parentheses whenever you enter a new value.

    As Sculpt Animate renders the frames it will ask for the
next disk by name when the time comes to write an image to
that disk.

    When all the frames have been rendered, Sculpt Animate
will begin to compress the image data. This is when the
anim file must be opened. It is best to have a blank floppy
disk dedicated to the anim file, since it can be very large.
This disk should be formatted beforehand, and its name
entered in the 'animation drawer' gadget of MODIFY
TAKE, GLOBAL mode.

    As the anim file is constructed, Sculpt Animate will again
ask to see each of the image disks in turn. If you have only
one floppy drive, this will undoubtedly incur a painful

                                                                        12-7

session of disk swapping, since the anim disk will also be
needed for each frame. If you have two floppy drives, you
can generally place the anim disk in one drive, then cycle the
image disks through the other. This avoids much, but not
all, of the disk swapping.

    There is a practical limit to the size of an anim file: about
850K. This is the maximum size of any file on an Amiga
floppy disk. It is possible that larger animation files may be
assembled on hard disks, but they must be split into portions
to be transported to floppies, public domain split programs
exist which will perform this function. The AmigaDOS
JOIN function can be used to re-assemble a split anim file.

Saving images

    You can reduce a great deal of the trouble of working
with floppies if you set the 'save images' gadget in the
MODIFY TAKE requester to NO.

    As we have seen, each image of an animation is normally
saved to disk when it is finished. With save images set to
NO, the animation will be compressed as it is rendered.
Images will still be written to disk, but the image files will be
deleted as soon as they are not needed. At most, five images
will be retained at one time.

    The drawback to this kind of animation is that any
interruption will make it necessary to re-start the entire
process from the beginning.

Color and exposure locking

    There are two variables in a scene that can cause radical
changes in the appearance of an image. These are the
scene's exposure and the image's color map. both of these
items are determined automatically when you render an
image with START, and are usually no cause for concern.

                                                                        12-8

    If each image were computed with an independent
automatic exposure value and one object were to move closer
to a lamp, then the overall brightness of the scene would be
reduced to prevent 'burn out' of the object near the lamp.
This would probably be a desirable action except for its
effect on delta compression. If the overall image is
darkened, most pixels would differ from one image to the
next and the efficiency of delta compression would suffer.

    When Sculpt Animate generates an image without using
HAM mode, the image is restricted to a color map of 16 or
32 colors, depending upon the resolution used. Each color
is chosen from a palette of 4096 possible colors in such a
way as to best represent a particular scene. The process of
delta compression requires that each frame uses the same set
of 16 or 32 colors. This also applies to HAM images,
because the 4096 colors that HAM can display must be
derived from a base color map of only 16.

    When the first frame of an animation is rendered, Sculpt
Animate will determine the best color map and exposure for
that image. These values will then be 'locked' throughout
the animation.

    You can have a little control over the color map that will
be chosen for your animation. If RENDER FRAME is used
to render the most representative frame of the animation, that
frame will determine the color map and exposure. If you
change your mind and want to start from scratch, click the
DELETE ALL IMAGES button. This resets the locks so
that the next frame rendered will determine their value.

    If, for some reason, you want the exposure value to
change during the course of the animation, you can 'animate'
the observer's manual exposure setting, saving different
values for different key frames in the animation. This will
usually make the compressed RAM animation much larger,
though. The manual exposure control can also be used to
change the overall brightness of the animation.

                                                                        12-9

Animating the observer

    Dramatic effects can be achieved by moving the
observer's location and target during an animation. The
visual effects produced this way can be very exciting, even if
only SKETCH or PAINTING mode is used. Often, more
information can be conveyed in this way than by using a
static viewpoint. As with objects, the observer can be
animated either by key frame animation or by global
animation.

    In global animation, the observer's location and target
must be attached to paths in the global scene's hierarchy.
The observer's location is called 'LOCATION'. and the
target is called "TARGET". These are 'special' names in the
hierarchy, and if they are entered into it they will be labeled
accordingly.

    When attached to a path, the location or target will follow
that path precisely. The location and target should always be
placed on separate paths, otherwise they would be in
the same place every frame! The target can be attached to the
same path as an object, this will cause the observer's view to
'track' that object's local origin.

    Other observer attributes can be animated in key frames,
as well. Specifically, the lens, exposure, and tilt. Simply
set these parameters differently in the key frame scenes, and
they will change smoothly in the animation. As usual, key
frame animation gives you the maximum creative freedom, at
the cost of a little extra work.

    If there are any key frame scenes defined for the
animation, then the observer will be positioned according to
those scenes. In this case, the observer's position in the
global scene will be ignored, unless it is named in the global
scene's hierarchy.

                                                                        12-10

    Even if a static view is being used, this is an important
fact. If you want to change the observer's location for a
large key frame animation, you can make the global scene's
observer 'take precedence', simply by putting the names
LOCATION and TARGET anywhere in the global scene's
hierarchy (the highest level will do).

    The only drawback to animating the observer is that the
compression ratio for RAM animation is reduced, often
dramatically, because most of the pixels that make up each
image will change from frame to frame. This may be of less
concern if you have a hard disk or other enormous storage
medium.

    When such drastic differences exist between frames, the
benefit of normal RAM animation compression is reduced.
In this case, you might as well click the RAM animation
gadget to ECONOMY to speed things up.

    When the compression efficiency is reduced, of course,
the animation playback speed will suffer as well, since the
processor will have that much more data to move between
frames.

    Later in this chapter, you will see how an animation's
images may be recorded on a professional quality videotape
recorder. This bypasses any need of RAM animation, and
all its restrictions.

Animating lamps

    The effect of moving lamps in a scene can be equally
dramatic, although the cost in processing and compression
can be even higher than that of moving the observer.
Nonetheless, if the animation is to be finally rendered in
photo mode, the moving shadows and highlights will give
the scene an amazing illusion of solidity and reality.

    In key frame animation, the lamp does not exist in the
global scene, but is positioned separately in each key frame.
You can also change the brightness and even the color of

                                                                        12-11

each lamp. If multiple lamps are used, then in-betweening
problems can occur unless you drag lamps with the
Grabber rather than creating new ones for each scene.

    In global animation, a lamp may be named and attached
to a path, just as if it were an object. Use the command
EDIT NAME INDICATED LAMP to do this.

Model Animation

    In the movies, a classic animation technique is to animate
models. A single picture taken and then the model is
moved a small amount and a second picture is taken. The
process is repeated until a complete animation has been
assembled.

    This technique can employ many different types of
models, frequently the models are rigid but with many
joined parts that can be set in particular positions.
Alternatively, a malleable medium like clay can be used,
which may require more skill but has almost unlimited
creative potential.

    In Sculpt Animate, solid models may be built and their
hierarchical object structure used to help manipulate them.

    We have already stressed some advantages of creating
such a model as a collection of parts. For instance, a human
model could comprise many elements constructed
individually. A forearm could first be fashioned with the
spin tool as a tapered cylinder with rounded ends. The
expand command could be used to introduce just the right
degree of asymmetry. Finally, some judicious manipulation
of individual vertices could add realism.

    An upper arm could be made in the same manner, and
the two parts made to overlap in space, so they appear to be
joined at the elbow. This is often quite adequate. Such
rigidly 'joined' objects lack the flexibility of skin, however,
so creases can appear when they are bent and repositioned.

                                                                        12-12

    This rigidity can be avoided by connecting the parts with
faces. This requires a good deal of skill, and not a little bit
of patience. The trick is to create 'fillets' of face-forming
edges that link one part with the other. Any vertices within
the joint that are not part of a visible face may then be erased.
The vertices on either side of the fillet may be named
differently, so when the joint moves the faces they form will
stretch and contract to form a pliable 'skin'. With foresight
you can arrange things so that the UNSLICE command can
be used to link the parts.

    The complete human model could be named in a
hierarchical manner, as suggested in Chapter 9. It then
becomes easy to select either a single component or a while
group of them. By placing the cursor at the location of a
joint and using the rotate gadgets, the model can be
manipulated just like a jointed doll. Although some skill is
required, the model can be moved to emulate any physical
activity, such as walking.

    The labor of animation is reduced by employing key
frames. A walking man animation requires fairly frequent
key frames, say one every four or five frames, but that is
still much better than having to build every scene.

    It is a good idea to place curves in the global scene, even
if you are not performing global animation. These curves act
as guides for positioning the model and help to ensure that
the motion is smooth and fluid. Just as the eye can detect
irregularities in a hand drawn line, it can also detect
irregularities in motion.

    Objects should not normally change their velocity
instantaneously. Have velocity build up and decrease
steadily. Remember that velocity is determined by the
difference in position of a vertex from one frame to the next.
The greater the difference, the greater the apparent velocity.

                                                                        12-13

Object Cycling

    There is a special feature of the global scene's hierarchy,
it is able to control the very existence of objects in different
parts of the animation. This special feature takes place
whenever an object's name begins with a numerical digit.
Such names are analyzed as follows:

    1)    If the name starts off as a number followed by a
        minus sign followed by a second number, then the
        vertex is only loaded if the frame number lies in
        that range. A vertex with the name '17-24apple'
        will only be loaded into frames 17 to 24.

    2)    If the name starts with a number followed by
        a slash and a second number, then the vertex is
        only loaded for the frame indicated by the first
        number, and then at intervals indicated by the
        second number. A vertex with the name
        '3/5orange' would only be loaded for frames 3, 8,
        13, 18, etc.

    3)    If the name starts with a number, but does not
        satisfy rules 1 and 2 above, then the vertex is only
        loaded for the frame with that number. The vertex
        names '17banana' is only loaded for frame 17.

    These three rules let you perform something called object
cycling. Suppose that you wish to animate an object that
moves in a regular manner and repeats the motion many
times. You can make a composite object that includes all
possible configurations, and name then so that they are
selected in turn for successive frames.

    Suppose that the name Henry is applied to a human
figure that has eight pairs of legs, each in a different
position. The first pair of legs has the name Henry+1/8legs,
the second pair Henry+2/8legs, etc. If this multi-legged
Henry is placed in the global scene, only the first pair of legs
will be loaded into the first frame, the second set will be
loaded into the second frame, and so on.

                                                                        12-14

    You may have noticed that this particular Henry moves
his legs back and forth, but he doesn't actually walk. To
make Henry walk, he must be attached to a path. The speed
along the path should be carefully chosen so that Henry's
feet do not seem to skid.

Animated objects

    Henry is an example of an animated object. He could be
saved as an object and used for other animations. Just as
you save interesting still objects for use in other scenes, you
can also save moving ones. There are many other ways to
build animated objects. Look at the scenes that are included
on the disks distributed with Sculpt Animate. Some of them
contain animated objects, study them to see how they work.

    Animated objects can be made by attaching objects to
paths, by object cycling, or by using both techniques
simultaneously. Let us go through the steps for creating a
spinning sphere. At first glance, the only way that we could
build a spinning sphere is by object cycling, but there is a
better and much easier way.

    First build a sphere in the usual way, and then construct
a hierarchy with a parent called 'spinning' and an offspring
called 'sphere'. Select each vertex of the sphere and assign
each vertex to the name 'sphere'. Set the local origin to the
center of the sphere.

    Now we must create a path that spins an object without
moving it. Deselect the sphere and add a circle. Proceed as
we did with the path named 'orbit' in Chapter 11.
Remember to rotate the tumble axes around the path, as was
explained in the 'Global vs. Key frame' section of that
chapter. Name the path 'spinning'. If we stopped at this
point, we would have a sphere spinning about an axis, but
following a circular orbit. To avoid the orbiting motion,
select the path and shrink it down with the EDIT DO
EXPAND command. You could keep clicking on the 1/2
gadget until the path shrank to a single point, but it is better
simply to make the circle much smaller than the sphere. That

                                                                        12-15

way you can still go in and easily modify the tumble axes if
you need to.

Backgrounds and foregrounds

    Although Sculpt Animate can be used to synthesize any
scene, sometimes it may be desirable to combine renderings
of three dimensional objects with background or foreground
images produced by other programs, such as paint
programs.

    You can specify background and foreground images in
the appropriately labeled boxes of the MODIFY TAKE
requester, GLOBAL mode.

    These particular gadgets require the complete AmigaDOS
pathname. Sculpt animate will also assume that the file's
names has the extension '.image', but do not type this
extension into the gadget. For example, if your background
image is named 'clouds.image' and its in the 'images'
drawer of a disk named 'Stuff', they you will type in
'Stuff:images/clouds'.

    As each image of the animation is rendered, the rendered
image will be combined with the foreground and background
images according to some simple rules:

    1)    Any pixel of a HAM foreground image that is not
        totally black will be shown in the final image.

    2)    Any pixel of a non-HAM foreground image that is
        not color zero will be shown in the final image.

    3)    If the world's sky is SOLID or GRADUATED, no
        background image pixels will be visible.

    4)     If the world's sky is NONE, the background image
        will replace any part of the sky area that is not
        blocked by a foreground image.

                                                                        12-16

    In other words, the rendered image that will be 'sandwiched'
between the foreground and background images, with the
former showing in front.

    Neither the foreground nor the background will have any
effect on the rendered imagery itself, or be affected by
shadows or scene lighting. Mirrored and glass objects will
look as if they sky were the SOLID color that was set before
the sky color gadget was toggled to NONE. The solid-sky
color is remembered, even though it is inactive otherwise.

    The foreground and background images may be any
standard IFF files, including HAM images. Their image size
and mode should not differ from the scene's settings. Sculpt
animate will attempt to resolve any such differences, but it
could significantly increase rendering time. Pixel
dimensions for Sculpt Animate's various sizes and
resolutions are listed in Chapter 3.

    If you must use a background image that differs in size
or mode from your animation, you can avoid having it
'fitted' to your scene more than once. To do this, render a
one-frame animation in the size and mode you want, using
the desired image as a background for a totally empty global
scene, with no sky or ground. You can use the resulting
corrected image as your background in the full animation.

    This suggests that background images can be generated
entirely with Sculpt Animate. In this way, distant objects
that do not move need only be rendered once. For
complicated scenes, this could represent a substantial time
saving when making a long animation.

    The foreground image can also portray objects as though
they were within the scene. Suppose all of an animation's
action takes place near the center of the screen, but which
has complicated objects in the foreground or to either side of
the action. As long as no shadows or reflections depend on
these objects, you could render an image of them with no
sky or ground, and use that image as a foreground for the
full animation. Leaving these objects out of the full
animation can reduce the total amount of rendering time.

                                                                        12-17

    In the ray trace modes, some time savings could be
realized by rendering one image of an animation, and
'blacking out' the area of motion with a HAM paint
program. The foreground pixels will usually be faster to
render than a full ray trace of the same pixel, even if all the
objects are still in the scene. Of course, the restrictions to
movement and shadows still apply.

Motion blurring

    When an animation has rapidly moving objects, each
image is sharply defined and the eye perceives the motion as
jerky rather than smooth, even at a frame rate of 30 frames
per second. A comparable film image would appear smooth
because each individual frame is slightly blurred.

    This blurring can be simulated in software by turning on
the Motion blur switch prior to rendering a Take.
Animations will take longer to produce, and because the
blurring is achieved by blending together adjacent images,
very rapidly moving objects will not have a correctly blurred
image, so some jerkiness will remain.

Single frame controllers

    The restrictions associated with RAM animations can be
avoided if each frame is directly recorded on a video tape
recorder, one frame at a time. Unfortunately, most
consumer grade recorders are not able to cleanly record one
frame at a time, so this technique is currently limited to the
video professional.

    If you plan to purchase a recorder and intend to use it fo
single frame recording, look for a recorder with 'flying erase
heads', and make sure it can record single frames cleanly at
the exact location you desire, without skipping or the image
breaking up. Naturally, there must be some mechanism for
controlling this.

                                                                        12-18

    Although some recorders can be operated manually to
record single frames, it is preferable to use special hardware
called a single frame controller, to act as an interface between
the Amiga and the recorder. Sculpt Animate is designed to
work with a special piece of software called a driver in order
to communicate with a single frame controller.

    A custom driver will have to be written for any particular
controller hardware, but only the driver must be changed.
Sculpt Animate itself can operate any controller device for
which a driver has been written.

    To use a single frame controller, you must set the RAM
animation gadget to NO. Two new gadgets will appear in
the Modify Take requester. One is called 'Frame controller'
and the other is called 'Frame buffer'. If you click on one of
these gadgets it will toggle to YES and a file requester will
pop up and ask you to choose from among the appropriate
drivers that are present in the system 'DEVS:' directory.

    Generating an animation to a frame controller is almost
the same as for RAM animation; click RENDER ALL to
begin. The images will be sent to the controller in the same
way they would be compressed, either as rendered or all at
once afterwards, depending on the state of the 'save images'
gadget.

Frame buffers

    A frame buffer is a piece of hardware that generates an
image independently of the Amiga's graphics hardware.
Depending upon the design, it may generate a higher
resolution image than the Amiga, or it may display more than
4096 colors, or both. Using a frame buffer can result in
better quality images than could be produced by the Amiga's
internal graphics hardware.

    The frame buffer is accessed by means of a driver similar
to the driver for a single frame controller. Its installation and
use must be described by the driver's documentation.

                                                                        12-19

    To select a frame buffer driver, click on the Frame buffer
gadget to change it from NO to YES, and then select the
driver using the file requester that will pop up.

    Sculpt Animate will interrogate the driver to determine
what size image is required, and other properties pertaining
to the frame buffer. No other special action is required,
although when rendering is started, the Amiga display may
or may not show the images as they are generated.

    If the 'save images' gadget is set to YES, the images will
be saved to disk in a compressed format similar to IFF's
ILBM. The format used is not IFF compatible, however,
because it will usually exceed ILBM's maximum resolution.

Connecting up the hardware

    As with any other hardware, carefully follow the
directions that are supplied. A typical setup has an Amiga, a
professional videotape recorder (VTR), a single frame
controller, and a frame buffer.

    The VTR will have some form of control hook-up
connected to the frame controller, which in turn will be
connected to the Amiga, probably through the serial or
parallel port. This is the control link.

    The VTR must also have video input, this can come
directly from the Amiga's composite output, from an NTSC
encoder or GenLock connected to the Amiga's RGB output,
or from a frame buffer connected to the Amiga's expansion
bus.

    In a typical animation recording session, the program
will display each image, either on the Amiga's display or by
passing it to a frame buffer driver, and then signal the frame
controller that the image is ready. This is repeated until
every frame is recorded.

    There is a vast amount of video hardware on the market
right not, and very little of it is truly suitable for single

                                                                        12-20